Input-mask-ios: संपादन के बाद गलत मुखौटा संलग्न

हो सकता है कि किसी भी मास्क के साथ शुरू होने के बाद टेक्स्टफिल्ड में मास्क को "लॉक" करने का कोई तरीका हो?

हाय @MrJox , आपकी रिपोर्ट के लिए धन्यवाद।
जब यह त्रुटि होती है तो क्या आप कृपया अपने टेक्स्ट फ़ील्ड के अंदर टेक्स्ट की सटीक स्थिति प्रदान कर सकते हैं?

मैं आज बाद में इसका पता लगा सकूंगा और फिर समाधान में आपकी सहायता कर सकूंगा।

निश्चित नहीं है कि राज्यों से आपका क्या मतलब है, लेकिन यहाँ क्या होता है:

मेरे पास कैश से पढ़ा गया एक फोन नंबर है और टेक्स्टफिल्ड में डाला गया है (यह एक कस्टम जेवीफ्लोट टेक्स्टफिल्ड है)।
फोन नंबर +7 (926) 000-00-00 है और फिर मैं '2' के बाद पॉइंटर सेट करता हूं और इस नंबर को हटा देता हूं। परिणामस्वरूप मेरी टेक्स्ट व्यू सामग्री 8 (796) 000-00-00 में परिवर्तित हो जाती है।

तो किसी कारण से यह + हटा देता है और 7 को मास्क के रूप में नहीं बल्कि फोन नंबर के वास्तविक हिस्से के रूप में मानता है और इसे ब्रैकेट में रखता है और फिर 8 मास्क जोड़ता है।

हाँ, आपका विवरण मेरे लिए काम करता है, धन्यवाद!
बने रहें।

@MrJox जब मैं अपने पिछले लाइब्रेरी अपडेट के लिए आवश्यक कुछ सुधारों और सुधारों पर काम कर रहा हूं, तो मैंने आपकी समस्या का त्वरित समाधान एक साथ रखा है।

प्रभावी रूप से, यह एक कस्टम एफ़िनिटी गणना पद्धति के साथ PolyMaskTextFieldDelegate संशोधन है। मुखौटा के साथ एक समग्र पाठ आत्मीयता के बजाय, यह विधि उपसर्गों के चौराहे की लंबाई, वर्णों की संख्या की तुलना करती है।

यह कोड या इसका संशोधित संस्करण अंततः पुस्तकालय स्रोतों के लिए अपना रास्ता खोज सकता है।

import Foundation
import UIKit

import InputMask

<strong i="10">@IBDesignable</strong>
class PrefixAffinityMaskedTextFieldDelegate: MaskedTextFieldDelegate {
    public var affineFormats: [String]

    public init(primaryFormat: String, affineFormats: [String]) {
        self.affineFormats = affineFormats
        super.init(format: primaryFormat)
    }

    public override init(format: String) {
        self.affineFormats = []
        super.init(format: format)
    }

    override open func put(text: String, into field: UITextField) {
        let mask: Mask = pickMask(
            forText: text,
            caretPosition: text.endIndex,
            autocomplete: autocomplete
        )

        let result: Mask.Result = mask.apply(
            toText: CaretString(
                string: text,
                caretPosition: text.endIndex
            ),
            autocomplete: autocomplete
        )

        field.text = result.formattedText.string
        field.caretPosition = result.formattedText.string.distance(
            from: result.formattedText.string.startIndex,
            to: result.formattedText.caretPosition
        )

        listener?.textField?(field, didFillMandatoryCharacters: result.complete, didExtractValue: result.extractedValue)
    }

    override open func deleteText(inRange range: NSRange, inTextInput field: UITextInput) -> Mask.Result {
        let text: String = replaceCharacters(
            inText: field.allText,
            range: range,
            withCharacters: ""
        )

        let mask: Mask = pickMask(
            forText: text,
            caretPosition: text.index(text.startIndex, offsetBy: range.location),
            autocomplete: false
        )

        let result: Mask.Result = mask.apply(
            toText: CaretString(
                string: text,
                caretPosition: text.index(text.startIndex, offsetBy: range.location)
            ),
            autocomplete: false
        )

        field.allText = result.formattedText.string
        field.caretPosition = range.location

        return result
    }

    override open func modifyText(
        inRange range: NSRange,
        inTextInput field: UITextInput,
        withText text: String
    ) -> Mask.Result {
        let updatedText: String = replaceCharacters(
            inText: field.allText,
            range: range,
            withCharacters: text
        )

        let mask: Mask = pickMask(
            forText: updatedText,
            caretPosition: updatedText.index(updatedText.startIndex, offsetBy: field.caretPosition + text.count),
            autocomplete: autocomplete
        )

        let result: Mask.Result = mask.apply(
            toText: CaretString(
                string: updatedText,
                caretPosition: updatedText.index(updatedText.startIndex, offsetBy: field.caretPosition + text.count)
            ),
            autocomplete: autocomplete
        )

        field.allText = result.formattedText.string
        field.caretPosition = result.formattedText.string.distance(
            from: result.formattedText.string.startIndex,
            to: result.formattedText.caretPosition
        )

        return result
    }

    func pickMask(forText text: String, caretPosition: String.Index, autocomplete: Bool) -> Mask {
        let primaryAffinity: Int = calculateAffinity(
            ofMask: mask,
            forText: text,
            caretPosition: caretPosition,
            autocomplete: autocomplete
        )

        var masks: [(Mask, Int)] = affineFormats.map { (affineFormat: String) -> (Mask, Int) in
            let mask:     Mask = try! Mask.getOrCreate(withFormat: affineFormat, customNotations: customNotations)
            let affinity: Int  = calculateAffinity(
                ofMask: mask,
                forText: text,
                caretPosition: caretPosition,
                autocomplete: autocomplete
            )

            return (mask, affinity)
        }

        masks.sort { (left: (Mask, Int), right: (Mask, Int)) -> Bool in
            return left.1 > right.1
        }

        var insertIndex: Int = -1

        for (index, maskAffinity) in masks.enumerated() {
            if primaryAffinity >= maskAffinity.1 {
                insertIndex = index
                break
            }
        }

        if (insertIndex >= 0) {
            masks.insert((mask, primaryAffinity), at: insertIndex)
        } else {
            masks.append((mask, primaryAffinity))
        }

        return masks.first!.0
    }

    func calculateAffinity(
        ofMask mask: Mask,
        forText text: String,
        caretPosition: String.Index,
        autocomplete: Bool
    ) -> Int {
        return mask.apply(
            toText: CaretString(
                string: text,
                caretPosition: caretPosition
            ),
            autocomplete: autocomplete
        ).formattedText.string.prefixIntersection(with: text).count
    }

    func replaceCharacters(inText text: String, range: NSRange, withCharacters newText: String) -> String {
        if 0 < range.length {
            let result = NSMutableString(string: text)
            result.replaceCharacters(in: range, with: newText)
            return result as String
        } else {
            let result = NSMutableString(string: text)
            result.insert(newText, at: range.location)
            return result as String
        }
    }

}


extension String {

    func prefixIntersection(with string: String) -> Substring {
        let lhsStartIndex = startIndex
        var lhsEndIndex = startIndex
        let rhsStartIndex = string.startIndex
        var rhsEndIndex = string.startIndex

        while (self[lhsStartIndex...lhsEndIndex] == string[rhsStartIndex...rhsEndIndex]) {
            lhsEndIndex = lhsEndIndex != endIndex ? index(after: lhsEndIndex) : endIndex
            rhsEndIndex = rhsEndIndex != string.endIndex ? string.index(after: rhsEndIndex) : endIndex

            if (lhsEndIndex == endIndex || rhsEndIndex == string.endIndex) {
                return self[lhsStartIndex..<lhsEndIndex]
            }
        }

        return self[lhsStartIndex..<lhsEndIndex]
    }

}


extension UITextInput {
    var allText: String {
        get {
            guard let all: UITextRange = allTextRange
                else { return "" }
            return self.text(in: all) ?? ""
        }

        set(newText) {
            guard let all: UITextRange = allTextRange
                else { return }
            self.replace(all, withText: newText)
        }
    }

    var caretPosition: Int {
        get {
            if let responder = self as? UIResponder {
                // Workaround for non-optional `beginningOfDocument`, which could actually be nil if field doesn't have focus
                guard responder.isFirstResponder
                    else { return allText.count }
            }

            if let range: UITextRange = selectedTextRange {
                let selectedTextLocation: UITextPosition = range.start
                return offset(from: beginningOfDocument, to: selectedTextLocation)
            } else {
                return 0
            }
        }

        set(newPosition) {
            if let responder = self as? UIResponder {
                // Workaround for non-optional `beginningOfDocument`, which could actually be nil if field doesn't have focus
                guard responder.isFirstResponder
                    else { return }
            }

            if newPosition > allText.count {
                return
            }

            let from: UITextPosition = position(from: beginningOfDocument, offset: newPosition)!
            let to:   UITextPosition = position(from: from, offset: 0)!
            selectedTextRange = textRange(from: from, to: to)
        }
    }

    var allTextRange: UITextRange? {
        return self.textRange(from: self.beginningOfDocument, to: self.endOfDocument)
    }
}

हम्म, तो अब मैं यह करता हूं:
<strong i="6">@IBOutlet</strong> var loginListener: PrefixAffinityMaskedTextFieldDelegate!

लेकिन यह अभी भी काम नहीं करेगा। मैंने क्या देखा, यदि आप डेल कुंजी के साथ ब्रैकेट के भीतर अंक हटाते हैं, तो अंक हटा दिया जाता है और अब यह ब्रैकेट के भीतर एक कम अंक है, हालांकि जब मैं बैकस्पेस बटन से हटाता हूं, तो यह या तो बाएं से अंक या दाएं से अंक को स्थानांतरित/स्थानांतरित करता है कोष्ठक के अंदर अंकों की मात्रा अपरिवर्तित रहती है।

मेरा मतलब:
मूल: +7 (916) 000-00-00
डेल कुंजी के साथ: +7 (96) 000-00-00
बैकस्पेस कुंजी के साथ: 8 (796) 000-00-00

सुधार:
अब ऐसा लगता है कि जब मैं टेक्स्टफिल्ड में स्ट्रिंग को हटाने का प्रयास करता हूं, तो मेरे पास केवल '+' वर्ण शेष होता है और जब मैं इसे हटाने का प्रयास करता हूं तो मेरा ऐप क्रैश हो जाता है

थ्रेड 1: घातक त्रुटि: एंडइंडेक्स से आगे नहीं बढ़ सकता

@MrJox मुझे यकीन नहीं है कि मैंने आपको सही ढंग से समझा है।
ध्यान दें, आईओएस पर कोई Del कुंजी नहीं है, केवल Backspace है। वर्चुअल कीबोर्ड इम्यूलेशन को मूर्ख मत बनने दो।

अपनी पिछली त्रुटि के संबंध में, आप किनारे के मामले के लिए निम्नलिखित पैच पर विचार कर सकते हैं:

extension String {

    func prefixIntersection(with string: String) -> Substring {
        guard !self.isEmpty && !string.isEmpty
        else { return "" }

        let lhsStartIndex = startIndex
        var lhsEndIndex = startIndex
        let rhsStartIndex = string.startIndex
        var rhsEndIndex = string.startIndex

        while (self[lhsStartIndex...lhsEndIndex] == string[rhsStartIndex...rhsEndIndex]) {
            lhsEndIndex = lhsEndIndex != endIndex ? index(after: lhsEndIndex) : endIndex
            rhsEndIndex = rhsEndIndex != string.endIndex ? string.index(after: rhsEndIndex) : endIndex

            if (lhsEndIndex == endIndex || rhsEndIndex == string.endIndex) {
                return self[lhsStartIndex..<lhsEndIndex]
            }
        }

        return self[lhsStartIndex..<lhsEndIndex]
    }

}

हाँ इसे ठीक कर दिया, धन्यवाद!

@MrJox मैं इस मुद्दे को अगले लाइब्रेरी अपडेट के साथ बंद कर दूंगा।
मैं इसे वैकल्पिक रणनीति के रूप में पुस्तकालय स्रोतों में जोड़ने पर विचार कर रहा हूं।

@MrJox अनुकूलित और सरलीकृत संस्करण:

extension String {

    func prefixIntersection(with string: String) -> Substring {
        var lhsIndex = startIndex
        var rhsIndex = string.startIndex

        while lhsIndex != endIndex && rhsIndex != string.endIndex {
            if self[...lhsIndex] == string[...rhsIndex] {
                lhsIndex = index(after: lhsIndex)
                rhsIndex = string.index(after: rhsIndex)
            } else {
                return self[..<lhsIndex]
            }
        }

        return self[..<lhsIndex]
    }

}

4.0.0 में यह एक विशेषता के रूप में शामिल है।