@salve-software/react-native-nitro-input-mask 1.0.0

package/android/src/main/java/com/nitroinputmask/NitroInputMaskTextWatcher.kt

@@ -0,0 +1,127 @@
+package com.nitroinputmask
+
+import android.text.Editable
+import android.text.TextWatcher
+import android.widget.EditText
+import com.nitroinputmask.engine.CursorEngine
+import com.nitroinputmask.engine.MaskEngineProtocol
+import java.lang.ref.WeakReference
+
+// Weak reference avoids EditText → TextWatcher → EditText retain cycle
+internal class NitroInputMaskTextWatcher(var engine: MaskEngineProtocol, editText: EditText) : TextWatcher {
+  private val editTextRef = WeakReference(editText)
+  var isProgrammatic = false
+  private var prevLength = 0
+  private var isDeletion = false
+  private var changeStart = 0
+  private var prevMasked = ""
+  private var prevCursorEnd = 0
+
+  override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
+    prevLength = s?.length ?: 0
+    isDeletion = after < count
+    prevMasked = s?.toString() ?: ""
+    prevCursorEnd = start + count
+  }
+
+  override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
+    changeStart = start
+  }
+
+  override fun afterTextChanged(s: Editable?) {
+    if (isProgrammatic) return
+    val editText = editTextRef.get() ?: return
+    val input = s?.toString()?.replace("\n", "") ?: ""
+
+    var (masked, _) = engine.apply(input)
+
+    // Separator deletion: masking re-produces the same text because the separator
+    // is always re-inserted. If there is data, block the deletion (text unchanged,
+    // cursor moves to just before the separator). If there is no data, clear the field.
+    var isSeparatorDeletion = false
+    if (isDeletion && masked == prevMasked) {
+      val (_, raw) = engine.apply(input)
+      if (raw.isEmpty()) {
+        masked = ""
+      } else {
+        isSeparatorDeletion = true
+        // masked stays == prevMasked; cursor will move to changeStart below
+      }
+    }
+
+    val cursorPos = when {
+      engine.wantsTrailingCursor -> when {
+        isSeparatorDeletion -> changeStart
+        isDeletion -> {
+          val digitsAfterDeleted = prevMasked.drop(prevCursorEnd).count { it.isDigit() }
+          if (digitsAfterDeleted == 0) {
+            masked.length
+          } else {
+            positionAfterDigits(prevMasked.take(changeStart).count { it.isDigit() }, masked)
+          }
+        }
+        else -> {
+          val digitsAfter = countDigits(prevMasked, prevCursorEnd)
+          cursorPositionWithDigitsAfter(digitsAfter, masked)
+        }
+      }
+      isDeletion -> minOf(changeStart, masked.length)
+      else -> {
+        val expMask = engine.expandedMask
+        if (expMask != null) {
+          val raw = CursorEngine.offsetAfterInsertion(prevMasked, masked, expMask, changeStart)
+          skipLeadingLiterals(raw, masked, expMask)
+        } else {
+          masked.length
+        }
+      }
+    }
+
+    if (masked == s?.toString()) {
+      editText.setSelection(cursorPos)
+    } else {
+      isProgrammatic = true
+      s?.replace(0, s.length, masked)
+      isProgrammatic = false
+      editText.setSelection(minOf(cursorPos, editText.text.length))
+    }
+  }
+
+  private fun positionAfterDigits(count: Int, text: String): Int {
+    if (count == 0) return text.indexOfFirst { it.isDigit() }.takeIf { it >= 0 } ?: 0
+    var found = 0
+    for (i in text.indices) {
+      if (text[i].isDigit()) {
+        found++
+        if (found == count) return i + 1
+      }
+    }
+    return text.length
+  }
+
+  private fun skipLeadingLiterals(offset: Int, masked: String, mask: String): Int {
+    val dataTokens = setOf('9', 'A', '*')
+    var idx = offset
+    while (idx < mask.length && mask[idx] !in dataTokens) idx++
+    return minOf(idx, masked.length)
+  }
+
+  private fun countDigits(text: String, from: Int): Int {
+    if (from >= text.length) return 0
+    return text.substring(from).count { it.isDigit() }
+  }
+
+  private fun cursorPositionWithDigitsAfter(count: Int, text: String): Int {
+    if (count == 0) return text.length
+    var digitsFromEnd = 0
+    var pos = text.length
+    while (pos > 0) {
+      pos--
+      if (text[pos].isDigit()) {
+        digitsFromEnd++
+        if (digitsFromEnd == count) return pos
+      }
+    }
+    return 0
+  }
+}

package/android/src/main/java/com/nitroinputmask/engine/CursorEngine.kt

@@ -0,0 +1,30 @@
+package com.nitroinputmask.engine
+
+object CursorEngine {
+  fun offsetAtEnd(masked: String, mask: String): Int {
+    for (i in masked.length - 1 downTo 0) {
+      if (i < mask.length && (mask[i] == '9' || mask[i] == 'A' || mask[i] == '*')) {
+        return i + 1
+      }
+    }
+    return masked.length
+  }
+
+  fun offsetAfterInsertion(oldMasked: String, newMasked: String, mask: String, at: Int): Int {
+    var dataRankBefore = 0
+    for (i in 0 until minOf(at, mask.length)) {
+      val m = mask[i]
+      if (m == '9' || m == 'A' || m == '*') dataRankBefore++
+    }
+    val targetRank = dataRankBefore + 1
+    var dataCount = 0
+    for (i in 0 until minOf(newMasked.length, mask.length)) {
+      val m = mask[i]
+      if (m == '9' || m == 'A' || m == '*') {
+        dataCount++
+        if (dataCount == targetRank) return i + 1
+      }
+    }
+    return newMasked.length
+  }
+}

package/android/src/main/java/com/nitroinputmask/engine/MaskEngine.kt

@@ -0,0 +1,261 @@
+package com.nitroinputmask.engine
+
+// ---------------------------------------------------------------------------
+// Slot — private internal representation of each compiled mask position
+// ---------------------------------------------------------------------------
+
+internal sealed class Slot {
+  object Digit : Slot()
+  object Letter : Slot()
+  object Any : Slot()
+  data class Literal(val char: Char) : Slot()
+
+  /**
+   * A slot that belongs to an inline `[from-to]` range.
+   *
+   * @param blockName  the range content string, e.g. "1-12" (used as the
+   *                   partial-tracking key; two ranges with identical bounds
+   *                   will share partial state — acceptable trade-off)
+   * @param position   0-based index of this slot within the range block
+   * @param length     total character width (= max(from.digits, to.digits))
+   * @param from       inclusive lower bound of the valid range
+   * @param to         inclusive upper bound of the valid range
+   */
+  data class RangeSlot(
+    val blockName: String,
+    val length: Int,
+    val from: Int,
+    val to: Int
+  ) : Slot()
+}
+
+// ---------------------------------------------------------------------------
+// CompiledMask — result of compile(); shared between MaskEngine and callers
+// ---------------------------------------------------------------------------
+
+internal data class CompiledMask(
+  internal val slots: List<Slot>,
+  /** Expanded mask string used by CursorEngine (range positions become '9'). */
+  val expandedMask: String
+) {
+  val isEmpty: Boolean get() = slots.isEmpty()
+}
+
+// ---------------------------------------------------------------------------
+// MaskEngine
+// ---------------------------------------------------------------------------
+
+object MaskEngine {
+
+  // -------------------------------------------------------------------------
+  // compile
+  // -------------------------------------------------------------------------
+
+  /**
+   * Compiles a mask string into a [CompiledMask].
+   *
+   * Supported tokens:
+   * - `9`         — any digit
+   * - `A`         — any letter
+   * - `*`         — any alphanumeric
+   * - `[from-to]` — integer range, e.g. `[1-12]`, `[1-31]`, `[0-23]`
+   * - any other character — literal
+   *
+   * Note: two `[from-to]` blocks with identical bounds share the same
+   * `blockName` key and therefore share partial-tracking state during
+   * [apply]. This is an acceptable trade-off; prefer distinct bounds when
+   * designing date masks (e.g. `[1-12]/[1-31]/9999`).
+   */
+  internal fun compile(mask: String): CompiledMask {
+    val slots = mutableListOf<Slot>()
+    val expanded = StringBuilder()
+    var i = 0
+
+    while (i < mask.length) {
+      if (mask[i] == '[') {
+        val closeIdx = mask.indexOf(']', i)
+        if (closeIdx == -1) {
+          // Malformed — treat '[' as a literal and advance past it.
+          slots.add(Slot.Literal('['))
+          expanded.append('[')
+          i++
+          continue
+        }
+        
+        val content = mask.substring(i + 1, closeIdx) // e.g. "1-12"
+        val dashIdx = content.indexOf('-')
+        val from = if (dashIdx > 0) content.substring(0, dashIdx).toIntOrNull() else null
+        val to = if (dashIdx > 0) content.substring(dashIdx + 1).toIntOrNull() else null
+        if (from != null && to != null) {
+          val length = maxOf(from.toString().length, to.toString().length)
+          repeat(length) {
+            slots.add(Slot.RangeSlot(content, length, from, to))
+            expanded.append('9')
+          }
+        } 
+        else {
+          // Malformed range — emit the entire "[...]" as individual literals.
+          val literal = "[$content]"
+          for (c in literal) { slots.add(Slot.Literal(c)); expanded.append(c) }
+        }
+        i = closeIdx + 1
+      } 
+      else {
+        when (val ch = mask[i]) {
+          '9' -> { slots.add(Slot.Digit);  expanded.append('9') }
+          'A' -> { slots.add(Slot.Letter); expanded.append('A') }
+          '*' -> { slots.add(Slot.Any);    expanded.append('*') }
+          else -> { slots.add(Slot.Literal(ch)); expanded.append(ch) }
+        }
+        i++
+      }
+    }
+
+    return CompiledMask(slots, expanded.toString())
+  }
+
+  // -------------------------------------------------------------------------
+  // apply
+  // -------------------------------------------------------------------------
+
+  internal fun apply(input: String, compiled: CompiledMask): Pair<String, String> {
+    if (compiled.slots.isEmpty()) return Pair(input, input)
+
+    val masked = StringBuilder()
+    val raw = StringBuilder()
+    val slots = compiled.slots
+
+    // Accumulate per-block digit strings so we can validate range prefixes
+    val blockPartials = mutableMapOf<String, StringBuilder>()
+
+    var ii = 0   // index into input characters
+    var si = 0   // index into slots
+
+    while (si < slots.size && ii < input.length) {
+      val slot = slots[si]
+      val c = input[ii]
+
+      when (slot) {
+        is Slot.Digit -> {
+          if (c.isDigit()) {
+            masked.append(c); raw.append(c); ii++; si++
+          } 
+          else {
+            ii++
+          }
+        }
+
+        is Slot.Letter -> {
+          if (c.isLetter()) {
+            masked.append(c); raw.append(c); ii++; si++
+          } 
+          else {
+            ii++
+          }
+        }
+
+        is Slot.Any -> {
+          if (c.isLetterOrDigit()) {
+            masked.append(c); raw.append(c); ii++; si++
+          } 
+          else {
+            ii++
+          }
+        }
+
+        is Slot.Literal -> {
+          masked.append(slot.char)
+          if (c == slot.char) ii++
+          si++
+        }
+
+        is Slot.RangeSlot -> {
+          if (c.isDigit()) {
+            val partial = blockPartials.getOrPut(slot.blockName) { StringBuilder() }
+            val candidate = partial.toString() + c
+
+            if (isValidPrefix(candidate, slot.from, slot.to, slot.length)) {
+              partial.append(c)
+              masked.append(c)
+              raw.append(c)
+              ii++
+              si++
+            }
+            else {
+              // Invalid digit for this range position — skip the input char
+              ii++
+            }
+          }
+          else {
+            // Non-digit where a range digit is expected — skip
+            ii++
+          }
+        }
+      }
+    }
+
+    // Only emit trailing literals if some input was actually consumed.
+    if (ii > 0) while (si < slots.size) {
+      val slot = slots[si]
+
+      if (slot is Slot.Literal) {
+        masked.append(slot.char)
+        si++
+      }
+      else {
+        break
+      }
+    }
+
+    return Pair(masked.toString(), raw.toString())
+  }
+
+  // -------------------------------------------------------------------------
+  // extractRaw
+  // -------------------------------------------------------------------------
+
+  internal fun extractRaw(text: String, compiled: CompiledMask): String {
+    return extractRaw(text, compiled.expandedMask)
+  }
+
+  private fun extractRaw(text: String, expandedMask: String): String {
+    val raw = StringBuilder()
+    val textChars = text.toList()
+    val maskChars = expandedMask.toList()
+    var ti = 0
+    var mi = 0
+
+    while (ti < textChars.size && mi < maskChars.size) {
+      val m = maskChars[mi]
+      if (m == '9' || m == 'A' || m == '*') {
+        raw.append(textChars[ti])
+        ti++
+        mi++
+      } 
+      else {
+        if (textChars[ti] == m) ti++
+        mi++
+      }
+    }
+
+    return raw.toString()
+  }
+
+  // -------------------------------------------------------------------------
+  // isValidPrefix
+  // -------------------------------------------------------------------------
+
+  /**
+   * Returns true if [partial] (the digits entered so far for a range block) is
+   * still consistent with producing a final value inside [from]..[to].
+   *
+   * After [partial] the remaining positions can be filled with '0'..'9', so we
+   * test whether the optimistic interval [min, max] overlaps [from, to].
+   */
+  private fun isValidPrefix(partial: String, from: Int, to: Int, length: Int): Boolean {
+    val remaining = length - partial.length
+    val partialMin = (partial + "0".repeat(remaining)).toIntOrNull() ?: return false
+    val partialMax = (partial + "9".repeat(remaining)).toIntOrNull() ?: return false
+    return partialMin <= to && partialMax >= from
+  }
+}

package/android/src/main/java/com/nitroinputmask/engine/MaskEngineFactory.kt

@@ -0,0 +1,18 @@
+package com.nitroinputmask.engine
+
+import com.margelo.nitro.nitroinputmask.NitroMaskOptions
+import com.nitroinputmask.masks.CreditCardMaskEngine
+import com.nitroinputmask.masks.CustomMaskEngine
+import com.nitroinputmask.masks.DatetimeMaskEngine
+import com.nitroinputmask.masks.MoneyMaskEngine
+
+internal object MaskEngineFactory {
+  fun build(maskType: String, options: NitroMaskOptions): MaskEngineProtocol {
+    return when (maskType) {
+      "money"       -> MoneyMaskEngine(options)
+      "datetime"    -> DatetimeMaskEngine(options.format ?: "DD/MM/YYYY")
+      "credit-card" -> CreditCardMaskEngine(options)
+      else          -> CustomMaskEngine(options.mask ?: "") // "custom"
+    }
+  }
+}

package/android/src/main/java/com/nitroinputmask/engine/MaskEngineProtocol.kt

@@ -0,0 +1,8 @@
+package com.nitroinputmask.engine
+
+interface MaskEngineProtocol {
+  fun apply(input: String): Pair<String, String>
+  val wantsTrailingCursor: Boolean
+  /** Expanded mask string for cursor positioning. Null means put cursor at end. */
+  val expandedMask: String?
+}

package/android/src/main/java/com/nitroinputmask/masks/CreditCardMaskEngine.kt

@@ -0,0 +1,47 @@
+package com.nitroinputmask.masks
+
+import com.margelo.nitro.nitroinputmask.NitroMaskOptions
+import com.nitroinputmask.engine.CompiledMask
+import com.nitroinputmask.engine.MaskEngine
+import com.nitroinputmask.engine.MaskEngineProtocol
+
+internal class CreditCardMaskEngine(options: NitroMaskOptions) : MaskEngineProtocol {
+  private val compiled: CompiledMask
+  private val obfuscated: Boolean = options.obfuscated ?: false
+
+  init {
+    val mask = when (options.issuer) {
+      "amex"   -> "9999 999999 99999"
+      "diners" -> "9999 999999 9999"
+      else     -> "9999 9999 9999 9999" // visa-or-mastercard (default)
+    }
+    compiled = MaskEngine.compile(mask)
+  }
+
+  override fun apply(input: String): Pair<String, String> {
+    val (masked, raw) = MaskEngine.apply(input, compiled)
+
+    if (obfuscated && masked.isNotEmpty()) {
+      return Pair(obfuscate(masked), raw)
+    }
+
+    return Pair(masked, raw)
+  }
+
+  override val wantsTrailingCursor: Boolean = false
+  override val expandedMask: String? = compiled.expandedMask
+
+  private fun obfuscate(masked: String): String {
+    val lastSpaceIdx = masked.lastIndexOf(' ')
+    if (lastSpaceIdx == -1) return masked // single group — don't obfuscate
+
+    val prefix = masked.substring(0, lastSpaceIdx + 1)
+    val lastGroup = masked.substring(lastSpaceIdx + 1)
+
+    val obfuscatedPrefix = prefix.map { c ->
+      if (c.isDigit()) '*' else c
+    }.joinToString("")
+
+    return obfuscatedPrefix + lastGroup
+  }
+}

package/android/src/main/java/com/nitroinputmask/masks/CustomMaskEngine.kt

@@ -0,0 +1,16 @@
+package com.nitroinputmask.masks
+
+import com.nitroinputmask.engine.CompiledMask
+import com.nitroinputmask.engine.MaskEngine
+import com.nitroinputmask.engine.MaskEngineProtocol
+
+internal class CustomMaskEngine(mask: String) : MaskEngineProtocol {
+  private val compiled: CompiledMask = MaskEngine.compile(mask)
+
+  override fun apply(input: String): Pair<String, String> {
+    return MaskEngine.apply(input, compiled)
+  }
+
+  override val wantsTrailingCursor: Boolean = false
+  override val expandedMask: String? = compiled.expandedMask
+}

package/android/src/main/java/com/nitroinputmask/masks/DatetimeMaskEngine.kt

@@ -0,0 +1,38 @@
+package com.nitroinputmask.masks
+
+import com.nitroinputmask.engine.CompiledMask
+import com.nitroinputmask.engine.MaskEngine
+import com.nitroinputmask.engine.MaskEngineProtocol
+
+internal class DatetimeMaskEngine(format: String) : MaskEngineProtocol {
+  private val compiled: CompiledMask = MaskEngine.compile(formatToPattern(format))
+
+  override fun apply(input: String): Pair<String, String> {
+    return MaskEngine.apply(input, compiled)
+  }
+
+  override val wantsTrailingCursor: Boolean = false
+  override val expandedMask: String? = compiled.expandedMask
+
+  companion object {
+    private fun formatToPattern(format: String): String {
+      val sb = StringBuilder()
+      var i = 0
+
+      while (i < format.length) {
+        when {
+          format.startsWith("YYYY", i) -> { sb.append("9999");    i += 4 }
+          format.startsWith("MM",   i) -> { sb.append("[1-12]");  i += 2 }
+          format.startsWith("DD",   i) -> { sb.append("[1-31]");  i += 2 }
+          format.startsWith("HH",   i) -> { sb.append("[0-23]");  i += 2 }
+          format.startsWith("hh",   i) -> { sb.append("[1-12]");  i += 2 }
+          format.startsWith("mm",   i) -> { sb.append("[0-59]");  i += 2 }
+          format.startsWith("ss",   i) -> { sb.append("[0-59]");  i += 2 }
+          else -> { sb.append(format[i]); i++ }
+        }
+      }
+
+      return sb.toString()
+    }
+  }
+}

package/android/src/main/java/com/nitroinputmask/masks/MoneyMaskEngine.kt

@@ -0,0 +1,66 @@
+package com.nitroinputmask.masks
+
+import com.margelo.nitro.nitroinputmask.NitroMaskOptions
+import com.nitroinputmask.engine.MaskEngineProtocol
+
+internal class MoneyMaskEngine(options: NitroMaskOptions) : MaskEngineProtocol {
+  private val precision: Int = (options.precision?.toInt()) ?: 2
+  private val separator: String = options.separator ?: ","
+  private val delimiter: String = options.delimiter ?: "."
+  private val unit: String = options.unit ?: ""
+  private val suffixUnit: String = options.suffixUnit ?: ""
+  private val zeroCents: Boolean = options.zeroCents ?: false
+
+  override fun apply(input: String): Pair<String, String> {
+    val digits = input.filter { it.isDigit() }
+
+    if (digits.isEmpty()) {
+      return Pair("", "")
+    }
+
+    val effectivePrecision = if (zeroCents) 0 else precision
+
+    // Pad on the left so we have at least (precision+1) digits
+    val minLength = effectivePrecision + 1
+    val padded = digits.padStart(maxOf(minLength, digits.length), '0')
+
+    // Split integer and decimal parts
+    var intPart: String
+    val centPart: String
+    if (effectivePrecision > 0) {
+      intPart = padded.dropLast(effectivePrecision)
+      centPart = padded.takeLast(effectivePrecision)
+    } else {
+      intPart = padded
+      centPart = ""
+    }
+
+    // Remove leading zeros from intPart, keep at least "0"
+    while (intPart.length > 1 && intPart.startsWith('0')) {
+      intPart = intPart.drop(1)
+    }
+
+    // Insert delimiter every 3 digits from right
+    val sb = StringBuilder()
+    val total = intPart.length
+    for (i in intPart.indices) {
+      sb.append(intPart[i])
+      val remaining = total - i - 1
+      if (remaining > 0 && remaining % 3 == 0) {
+        sb.append(delimiter)
+      }
+    }
+
+    // Build result
+    var masked = unit + sb.toString()
+    if (effectivePrecision > 0) {
+      masked += separator + centPart
+    }
+    masked += suffixUnit
+
+    return Pair(masked, digits)
+  }
+
+  override val wantsTrailingCursor: Boolean = true
+  override val expandedMask: String? = null
+}

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  nitro-input-mask
+//
+//  Created by salvesoftware on 5/8/2026
+//
+
+#pragma once