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

package/ios/NitroInputMaskDelegateProxy.swift

@@ -0,0 +1,194 @@
+import UIKit
+
+class NitroInputMaskDelegateProxy: NSObject, UITextFieldDelegate {
+  var engine: MaskEngineProtocol
+  weak var original: UITextFieldDelegate?
+
+  init(engine: MaskEngineProtocol, original: UITextFieldDelegate?) {
+    self.engine = engine
+    self.original = original
+  }
+
+  func textField(
+    _ textField: UITextField,
+    shouldChangeCharactersIn range: NSRange,
+    replacementString string: String
+  ) -> Bool {
+    let current = textField.text ?? ""
+    guard let swiftRange = Range(range, in: current) else { return false }
+    let proposed = current.replacingCharacters(in: swiftRange, with: string)
+
+    let isDeletion = string.isEmpty
+    var (masked, raw) = engine.apply(input: proposed)
+
+    // Empty mask (custom with no mask string) — pass through
+    if masked.isEmpty && raw.isEmpty && !proposed.isEmpty {
+      let (_, currentRaw) = engine.apply(input: current)
+      if currentRaw.isEmpty {
+        textField.text = proposed
+        textField.sendActions(for: .editingChanged)
+        return false
+      }
+    }
+
+    // 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 == current {
+      let (_, extractedRaw) = engine.apply(input: current)
+      if extractedRaw.isEmpty {
+        masked = ""
+      } else {
+        isSeparatorDeletion = true
+        // masked stays == current; cursor will move to range.location below
+      }
+    }
+
+    textField.text = masked
+
+    if engine.wantsTrailingCursor {
+      let cursorPos: Int
+      if isSeparatorDeletion {
+        // Separator deleted: move to just before it so next backspace hits a real digit.
+        cursorPos = range.location
+      } else if isDeletion {
+        // If the cursor was at the trailing edge (no digits after the deleted
+        // char), stay at the end of the new string — RTL money digits shift left
+        // and the "digits before" anchor would land one position short.
+        // Otherwise use the digits-before anchor so the cursor survives a
+        // thousands separator being removed (e.g. 1.123,55 → 112,55).
+        let digitsAfterDeleted = countDigits(in: current, from: range.location + range.length)
+
+        if digitsAfterDeleted == 0 {
+          cursorPos = masked.count
+        } else {
+          let digitsBeforeRange = countDigitsUpTo(in: current, upTo: range.location)
+          cursorPos = positionAfterDigits(digitsBeforeRange, in: masked)
+        }
+      } else {
+        // Insertion: use "digits from end" so cursor survives magnitude changes.
+        let digitsAfterCursor = countDigits(in: current, from: range.location + range.length)
+        cursorPos = cursorPositionWithDigitsAfter(digitsAfterCursor, in: masked)
+      }
+      if let pos = textField.position(from: textField.beginningOfDocument, offset: cursorPos) {
+        textField.selectedTextRange = textField.textRange(from: pos, to: pos)
+      }
+    } else if let expandedMask = engine.expandedMask {
+      let cursorOffset: Int
+
+      if isDeletion {
+        cursorOffset = min(range.location, masked.count)
+      } else {
+        let raw = CursorEngine.offsetAfterInsertion(
+          oldMasked: current,
+          newMasked: masked,
+          mask: expandedMask,
+          at: range.location
+        )
+        // Advance past any auto-inserted literals immediately following the cursor.
+        cursorOffset = skipLeadingLiterals(at: raw, in: masked, mask: expandedMask)
+      }
+      if let pos = textField.position(from: textField.beginningOfDocument, offset: cursorOffset) {
+        textField.selectedTextRange = textField.textRange(from: pos, to: pos)
+      }
+    } else {
+      let endPos = masked.count
+
+      if let pos = textField.position(from: textField.beginningOfDocument, offset: endPos) {
+        textField.selectedTextRange = textField.textRange(from: pos, to: pos)
+      }
+    }
+
+    textField.sendActions(for: .editingChanged)
+    return false
+  }
+
+  func textFieldShouldReturn(_ textField: UITextField) -> Bool {
+    textField.resignFirstResponder()
+    return original?.textFieldShouldReturn?(textField) ?? true
+  }
+
+  override func responds(to aSelector: Selector!) -> Bool {
+    super.responds(to: aSelector) || (original?.responds(to: aSelector) ?? false)
+  }
+
+  override func forwardingTarget(for aSelector: Selector!) -> Any? {
+    if original?.responds(to: aSelector) == true { return original }
+    return super.forwardingTarget(for: aSelector)
+  }
+
+  // MARK: - Cursor helpers
+
+  /// Advances `offset` past any consecutive literal slots in `mask`, so the
+  /// cursor lands after auto-inserted separators rather than before them.
+  private func skipLeadingLiterals(at offset: Int, in masked: String, mask: String) -> Int {
+    let dataTokens: Set<Character> = ["9", "A", "*"]
+    let maskChars = Array(mask)
+    var idx = offset
+
+    while idx < maskChars.count && !dataTokens.contains(maskChars[idx]) {
+      idx += 1
+    }
+    return min(idx, masked.count)
+  }
+
+  /// Counts digit characters in `text` before index `upTo`.
+  private func countDigitsUpTo(in text: String, upTo: Int) -> Int {
+    let chars = Array(text)
+    let limit = min(upTo, chars.count)
+    return chars[0..<limit].filter { $0.isNumber }.count
+  }
+
+  /// Returns the position in `text` immediately after the `count`-th digit.
+  /// When `count` is 0, returns the index of the first digit (past any unit
+  /// prefix) so the cursor lands before the content, not before the unit.
+  /// Falls back to `text.count` when fewer digits exist.
+  private func positionAfterDigits(_ count: Int, in text: String) -> Int {
+    let chars = Array(text)
+
+    if count == 0 {
+      return chars.enumerated().first(where: { $0.element.isNumber })?.offset ?? 0
+    }
+
+    var found = 0
+    for (i, c) in chars.enumerated() {
+      if c.isNumber {
+        found += 1
+        if found == count { return i + 1 }
+      }
+    }
+    return text.count
+  }
+
+  /// Returns how many digit characters exist in `text` starting from `start`.
+  private func countDigits(in text: String, from start: Int) -> Int {
+    guard start < text.count else { return 0 }
+    let chars = Array(text)
+    var count = 0
+
+    for i in start..<chars.count where chars[i].isNumber {
+      count += 1
+    }
+    return count
+  }
+
+  /// Returns the cursor position in `text` such that exactly `count` digit
+  /// characters appear after it. Used for RTL money masks so the cursor
+  /// stays near the edit point after reformatting.
+  private func cursorPositionWithDigitsAfter(_ count: Int, in text: String) -> Int {
+    if count == 0 { return text.count }
+    let chars = Array(text)
+    var digitsFromEnd = 0
+    var pos = chars.count
+
+    while pos > 0 {
+      pos -= 1
+      if chars[pos].isNumber {
+        digitsFromEnd += 1
+        if digitsFromEnd == count { return pos }
+      }
+    }
+    return 0
+  }
+}

package/ios/NitroInputMaskModule.swift

@@ -0,0 +1,114 @@
+import NitroModules
+import UIKit
+
+private let attachRetries = 5
+private let attachRetryDelay: TimeInterval = 0.05
+
+class HybridNitroInputMaskModule: HybridNitroInputMaskSpec_base, HybridNitroInputMaskSpec_protocol {
+  private var proxies: [String: NitroInputMaskDelegateProxy] = [:]
+
+  func attach(nativeID: String, maskType: String, options: NitroMaskOptions) throws {
+    let engine = MaskEngineFactory.build(maskType: maskType, options: options)
+    attemptAttach(nativeID: nativeID, engine: engine, retries: attachRetries)
+  }
+
+  private func attemptAttach(nativeID: String, engine: MaskEngineProtocol, retries: Int) {
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+
+      if let tf = self.findTextField(nativeID: nativeID) {
+        let proxy = NitroInputMaskDelegateProxy(engine: engine, original: tf.delegate)
+        tf.delegate = proxy
+        self.proxies[nativeID] = proxy
+      } else if retries > 0 {
+        DispatchQueue.main.asyncAfter(deadline: .now() + attachRetryDelay) { [weak self] in
+          self?.attemptAttach(nativeID: nativeID, engine: engine, retries: retries - 1)
+        }
+      }
+    }
+  }
+
+  func detach(nativeID: String) throws {
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+      guard let proxy = self.proxies.removeValue(forKey: nativeID) else { return }
+
+      if let tf = self.findTextField(nativeID: nativeID) {
+        tf.delegate = proxy.original
+      }
+    }
+  }
+
+  func updateMask(nativeID: String, maskType: String, options: NitroMaskOptions) throws {
+    let engine = MaskEngineFactory.build(maskType: maskType, options: options)
+    proxies[nativeID]?.engine = engine
+  }
+
+  func setValue(nativeID: String, rawValue: String) throws {
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+      guard let proxy = self.proxies[nativeID] else { return }
+      guard let tf = self.findTextField(nativeID: nativeID) else { return }
+
+      let (masked, _) = proxy.engine.apply(input: rawValue)
+      guard tf.text != masked else { return }
+      tf.text = masked
+
+      if proxy.engine.wantsTrailingCursor {
+        let endPos = masked.count
+        if let pos = tf.position(from: tf.beginningOfDocument, offset: endPos) {
+          tf.selectedTextRange = tf.textRange(from: pos, to: pos)
+        }
+      } else if let expandedMask = proxy.engine.expandedMask {
+        CursorEngine.apply(to: tf, masked: masked, mask: expandedMask)
+      }
+    }
+  }
+
+  private func findTextField(nativeID: String) -> UITextField? {
+    let windows: [UIWindow]
+
+    if #available(iOS 15.0, *) {
+      windows = UIApplication.shared.connectedScenes
+        .compactMap { $0 as? UIWindowScene }
+        .flatMap { $0.windows }
+    } else {
+      windows = UIApplication.shared.windows
+    }
+
+    for window in windows {
+      if let container = findView(in: window, identifier: nativeID),
+        let tf = findFirstTextField(in: container)
+      {
+        return tf
+      }
+    }
+    return nil
+  }
+
+  private func findView(in view: UIView, identifier: String) -> UIView? {
+    for selName in ["nativeId", "nativeID"] {
+      let sel = NSSelectorFromString(selName)
+      if view.responds(to: sel),
+        let id = view.perform(sel)?.takeUnretainedValue() as? String,
+        id == identifier
+      {
+        return view
+      }
+    }
+
+    for sv in view.subviews {
+      if let found = findView(in: sv, identifier: identifier) { return found }
+    }
+    return nil
+  }
+
+  private func findFirstTextField(in view: UIView) -> UITextField? {
+    if let tf = view as? UITextField { return tf }
+
+    for sv in view.subviews {
+      if let found = findFirstTextField(in: sv) { return found }
+    }
+    return nil
+  }
+}

package/ios/NitroInputMaskServiceModule.swift

@@ -0,0 +1,11 @@
+import NitroModules
+
+class HybridNitroInputMaskServiceModule: HybridNitroInputMaskServiceSpec_base,
+  HybridNitroInputMaskServiceSpec_protocol
+{
+  func applyMask(value: String, maskType: String, options: NitroMaskOptions) throws -> String {
+    let engine = MaskEngineFactory.build(maskType: maskType, options: options)
+    let (masked, _) = engine.apply(input: value)
+    return masked
+  }
+}

package/ios/engine/CursorEngine.swift

@@ -0,0 +1,52 @@
+import UIKit
+
+enum CursorEngine {
+  static func offsetAtEnd(masked: String, mask: String) -> Int {
+    let maskChars = Array(mask)
+    var result = masked.count
+    for i in stride(from: min(masked.count, mask.count) - 1, through: 0, by: -1) {
+      let m = maskChars[i]
+      if m == "9" || m == "A" || m == "*" {
+        result = i + 1
+        break
+      }
+    }
+    return result
+  }
+
+  /// Returns the cursor offset after inserting one character at `insertionPoint`
+  /// in `oldMasked`, producing `newMasked`.
+  static func offsetAfterInsertion(
+    oldMasked: String, newMasked: String, mask: String, at insertionPoint: Int
+  ) -> Int {
+    let maskChars = Array(mask)
+
+    // Count data chars before insertionPoint in the old masked string
+    var dataRankBefore = 0
+    for i in 0..<min(insertionPoint, maskChars.count) {
+      let m = maskChars[i]
+      if m == "9" || m == "A" || m == "*" { dataRankBefore += 1 }
+    }
+
+    // Find position after the (dataRankBefore + 1)-th data char in new masked string
+    let targetRank = dataRankBefore + 1
+    var dataCount = 0
+    for i in 0..<min(newMasked.count, maskChars.count) {
+      let m = maskChars[i]
+      if m == "9" || m == "A" || m == "*" {
+        dataCount += 1
+        if dataCount == targetRank { return i + 1 }
+      }
+    }
+
+    return newMasked.count
+  }
+
+  static func apply(to textField: UITextField, masked: String, mask: String) {
+    let off = offsetAtEnd(masked: masked, mask: mask)
+    guard let pos = textField.position(from: textField.beginningOfDocument, offset: off) else {
+      return
+    }
+    textField.selectedTextRange = textField.textRange(from: pos, to: pos)
+  }
+}

package/ios/engine/MaskEngine.swift

@@ -0,0 +1,221 @@
+import Foundation
+
+// MARK: - Slot
+
+private enum Slot {
+  case digit
+  case letter
+  case any
+  case literal(Character)
+  case range(blockName: String, length: Int, from: Int, to: Int)
+}
+
+// MARK: - CompiledMask
+
+struct CompiledMask {
+  fileprivate let slots: [Slot]
+  let expandedMask: String
+  var isEmpty: Bool { slots.isEmpty }
+}
+
+// MARK: - MaskEngine
+
+enum MaskEngine {
+
+  // MARK: 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`).
+  static func compile(mask: String) -> CompiledMask {
+    var slots: [Slot] = []
+    var expandedMask = ""
+    var i = mask.startIndex
+
+    while i < mask.endIndex {
+      if mask[i] == "[" {
+        guard let closeIdx = mask[i...].firstIndex(of: "]") else {
+          // Malformed — treat "[" as a literal and advance past it.
+          slots.append(.literal("["))
+          expandedMask.append("[")
+          i = mask.index(after: i)
+          continue
+        }
+
+        let content = String(mask[mask.index(after: i)..<closeIdx])  // e.g. "1-12"
+        let parts = content.split(separator: "-", maxSplits: 1)
+        if parts.count == 2, let from = Int(parts[0]), let to = Int(parts[1]) {
+          let length = max(String(from).count, String(to).count)
+          for _ in 0..<length {
+            slots.append(.range(blockName: content, length: length, from: from, to: to))
+            expandedMask.append("9")
+          }
+        } else {
+          // Malformed range — emit the entire "[...]" as individual literals.
+          let literal = "[" + content + "]"
+          for c in literal {
+            slots.append(.literal(c))
+            expandedMask.append(c)
+          }
+        }
+        i = mask.index(after: closeIdx)
+      } else {
+        switch mask[i] {
+        case "9":
+          slots.append(.digit)
+          expandedMask.append("9")
+
+        case "A":
+          slots.append(.letter)
+          expandedMask.append("A")
+
+        case "*":
+          slots.append(.any)
+          expandedMask.append("*")
+
+        default:
+          slots.append(.literal(mask[i]))
+          expandedMask.append(mask[i])
+        }
+        i = mask.index(after: i)
+      }
+    }
+
+    return CompiledMask(slots: slots, expandedMask: expandedMask)
+  }
+
+  // MARK: apply
+
+  static func apply(input: String, compiled: CompiledMask) -> (masked: String, raw: String) {
+    if compiled.slots.isEmpty { return (input, input) }
+
+    var masked = ""
+    var raw = ""
+    let slots = compiled.slots
+    let inputChars = Array(input)
+    var ii = 0
+    var si = 0
+    var blockPartials: [String: String] = [:]
+
+    while si < slots.count && ii < inputChars.count {
+      let slot = slots[si]
+      let c = inputChars[ii]
+
+      switch slot {
+      case .digit:
+        if c.isNumber {
+          masked.append(c)
+          raw.append(c)
+          ii += 1
+          si += 1
+        } else {
+          ii += 1
+        }
+
+      case .letter:
+        if c.isLetter {
+          masked.append(c)
+          raw.append(c)
+          ii += 1
+          si += 1
+        } else {
+          ii += 1
+        }
+
+      case .any:
+        if c.isLetter || c.isNumber {
+          masked.append(c)
+          raw.append(c)
+          ii += 1
+          si += 1
+        } else {
+          ii += 1
+        }
+
+      case .literal(let lc):
+        masked.append(lc)
+        if c == lc { ii += 1 }
+        si += 1
+
+      case .range(let blockName, let length, let from, let to):
+        if c.isNumber {
+          let partial = blockPartials[blockName, default: ""]
+          let newPartial = partial + String(c)
+          if isValidPrefix(partial: newPartial, from: from, to: to, length: length) {
+            masked.append(c)
+            raw.append(c)
+            blockPartials[blockName] = newPartial
+            ii += 1
+            si += 1
+          } else {
+            ii += 1
+          }
+        } else {
+          ii += 1
+        }
+      }
+    }
+
+    // Only emit trailing literals if some input was actually consumed.
+    if ii > 0 {
+      while si < slots.count, case .literal(let lc) = slots[si] {
+        masked.append(lc)
+        si += 1
+      }
+    }
+
+    return (masked, raw)
+  }
+
+  // MARK: extractRaw
+
+  static func extractRaw(from text: String, compiled: CompiledMask) -> String {
+    return extractRaw(from: text, mask: compiled.expandedMask)
+  }
+
+  // MARK: Private helpers
+
+  private static func extractRaw(from text: String, mask: String) -> String {
+    var raw = ""
+    let textChars = Array(text)
+    let maskChars = Array(mask)
+    var ti = 0
+    var mi = 0
+
+    while ti < textChars.count && mi < maskChars.count {
+      let m = maskChars[mi]
+
+      if m == "9" || m == "A" || m == "*" {
+        raw.append(textChars[ti])
+        ti += 1
+        mi += 1
+      } else {
+        if textChars[ti] == maskChars[mi] { ti += 1 }
+        mi += 1
+      }
+    }
+
+    return raw
+  }
+
+  private static func isValidPrefix(partial: String, from: Int, to: Int, length: Int) -> Bool {
+    let remaining = length - partial.count
+    guard remaining >= 0 else { return false }
+    guard
+      let partialMin = Int(partial + String(repeating: "0", count: remaining)),
+      let partialMax = Int(partial + String(repeating: "9", count: remaining))
+    else { return false }
+
+    return partialMin <= to && partialMax >= from
+  }
+}

package/ios/engine/MaskEngineFactory.swift

@@ -0,0 +1,16 @@
+import NitroModules
+
+enum MaskEngineFactory {
+  static func build(maskType: String, options: NitroMaskOptions) -> MaskEngineProtocol {
+    switch maskType {
+    case "money":
+      return MoneyMaskEngine(options: options)
+    case "datetime":
+      return DatetimeMaskEngine(format: options.format ?? "DD/MM/YYYY")
+    case "credit-card":
+      return CreditCardMaskEngine(options: options)
+    default:  // "custom"
+      return CustomMaskEngine(mask: options.mask ?? "")
+    }
+  }
+}

package/ios/engine/MaskEngineProtocol.swift

@@ -0,0 +1,7 @@
+protocol MaskEngineProtocol {
+  func apply(input: String) -> (masked: String, raw: String)
+  var wantsTrailingCursor: Bool { get }
+  /// Expanded mask string used for cursor positioning (e.g. "999.999.999-99").
+  /// Return nil if cursor should just go to end of masked string.
+  var expandedMask: String? { get }
+}

package/ios/masks/CreditCardMaskEngine.swift

@@ -0,0 +1,57 @@
+import NitroModules
+
+struct CreditCardMaskEngine: MaskEngineProtocol {
+  private let compiled: CompiledMask
+  private let obfuscated: Bool
+
+  init(options: NitroMaskOptions) {
+    let issuer = options.issuer ?? "visa-or-mastercard"
+    self.obfuscated = options.obfuscated ?? false
+
+    let mask: String
+    switch issuer {
+    case "amex":
+      mask = "9999 999999 99999"
+    case "diners":
+      mask = "9999 999999 9999"
+    default:  // visa-or-mastercard
+      mask = "9999 9999 9999 9999"
+    }
+
+    self.compiled = MaskEngine.compile(mask: mask)
+  }
+
+  func apply(input: String) -> (masked: String, raw: String) {
+    let (masked, raw) = MaskEngine.apply(input: input, compiled: compiled)
+
+    if obfuscated && !masked.isEmpty {
+      let obfuscatedMasked = CreditCardMaskEngine.obfuscate(masked)
+      return (obfuscatedMasked, raw)
+    }
+
+    return (masked, raw)
+  }
+
+  var wantsTrailingCursor: Bool { false }
+  var expandedMask: String? { compiled.expandedMask }
+
+  // MARK: - Obfuscation
+
+  private static func obfuscate(_ masked: String) -> String {
+    guard let lastSpaceIdx = masked.lastIndex(of: " ") else {
+      // No spaces — single group, don't obfuscate
+      return masked
+    }
+
+    let lastGroupStart = masked.index(after: lastSpaceIdx)
+    let prefix = String(masked[masked.startIndex..<lastGroupStart])
+    let lastGroup = String(masked[lastGroupStart...])
+
+    // Replace digit characters with * in prefix, keep spaces intact
+    let obfuscatedPrefix = prefix.map { c -> Character in
+      c.isNumber ? "*" : c
+    }
+
+    return String(obfuscatedPrefix) + lastGroup
+  }
+}

package/ios/masks/CustomMaskEngine.swift

@@ -0,0 +1,16 @@
+import NitroModules
+
+struct CustomMaskEngine: MaskEngineProtocol {
+  private let compiled: CompiledMask
+
+  init(mask: String) {
+    self.compiled = MaskEngine.compile(mask: mask)
+  }
+
+  func apply(input: String) -> (masked: String, raw: String) {
+    return MaskEngine.apply(input: input, compiled: compiled)
+  }
+
+  var wantsTrailingCursor: Bool { false }
+  var expandedMask: String? { compiled.expandedMask }
+}