@react-native-ohos/react-native-text-input-mask 3.1.6-rc.3 → 3.1.6-rc.5

package/harmony/text_input_mask/src/main/cpp/common/FormatError.h

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef FORMATERROR_H
+#define FORMATERROR_H
 #pragma once
 // 定义 FormatError 类
 #include <string>
@@ -13,11 +14,10 @@ class FormatError : public std::exception {
 public:
     // 构造函数接受错误消息
     explicit FormatError(const std::string &message = "An error occurred") : msg(message) {}
-
     // 重写 what() 方法，返回错误消息
-    const char *what() const noexcept { return msg.c_str(); }
-
+    const char *what() const noexcept override { return msg.c_str(); }
 private:
     std::string msg; // 存储错误消息
 };
-} // namespace TinpMask
+} // namespace TinpMask
+#endif

package/harmony/text_input_mask/src/main/cpp/common/FormatSanitizer.h

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef FORMATSANITIZER_H
+#define FORMATSANITIZER_H
 #pragma once
 #include <iostream>
 #include <vector>
@@ -17,13 +18,15 @@ namespace TinpMask {
 class Compiler;
 class FormatSanitizer {
 public:
-    std::string sanitize(const std::string &formatString) {
+    std::string sanitize(const std::string &formatString)
+    {
         checkOpenBraces(formatString);
         std::vector<std::string> blocks = divideBlocksWithMixedCharacters(getFormatBlocks(formatString));
         return sortFormatBlocks(blocks);
     }
 
-    std::vector<std::string> getFormatBlocks(const std::string &formatString) {
+    std::vector<std::string> getFormatBlocks(const std::string &formatString)
+    {
         std::vector<std::string> blocks;
         std::string currentBlock;
         bool escape = false;
@@ -36,36 +39,30 @@ public:
                     continue;
                 }
             }
-
             if ((ch == '[' || ch == '{') && !escape) {
                 if (!currentBlock.empty()) {
                     blocks.push_back(currentBlock);
                 }
                 currentBlock.clear();
             }
-
             currentBlock += ch;
 
             if ((ch == ']' || ch == '}') && !escape) {
                 blocks.push_back(currentBlock);
                 currentBlock.clear();
             }
-
             escape = false;
         }
 
         if (!currentBlock.empty()) {
             blocks.push_back(currentBlock);
         }
-
         return blocks;
     }
-
-
 public:
-    std::vector<std::string> divideBlocksWithMixedCharacters(const std::vector<std::string> &blocks) {
+    std::vector<std::string> divideBlocksWithMixedCharacters(const std::vector<std::string> &blocks)
+    {
         std::vector<std::string> resultingBlocks;
-
         for (const auto &block : blocks) {
             if (!block.empty() && block.substr(0, 1) == "[") { // 使用 substr 来检查开头
                 std::string blockBuffer;
@@ -114,7 +111,6 @@ public:
                 resultingBlocks.push_back(block);
             }
         }
-
         return resultingBlocks;
     }
 
@@ -127,7 +123,8 @@ private:
 
     bool isSpecialCharacter(char ch) const { return ch == '-' || ch == '_'; }
 
-    bool containsAny(const std::string &str, const std::vector<char> &characters) const {
+    bool containsAny(const std::string &str, const std::vector<char> &characters) const
+    {
         for (char c : characters) {
             if (str.find(c) != std::string::npos) {
                 return true;
@@ -135,9 +132,9 @@ private:
         }
         return false;
     }
-
 public:
-    std::string sortFormatBlocks(const std::vector<std::string> &blocks) {
+    std::string sortFormatBlocks(const std::vector<std::string> &blocks)
+    {
         std::vector<std::string> sortedBlocks;
 
         for (const auto &block : blocks) {
@@ -162,12 +159,11 @@ public:
 
         return join(sortedBlocks); // Ensure this is returning std::vector<std::string>
     }
-
-    void checkOpenBraces(const std::string &inputString) {
+    void checkOpenBraces(const std::string &inputString)
+    {
         bool escape = false;
         bool squareBraceOpen = false;
         bool curlyBraceOpen = false;
-
         for (const char &ch : inputString) {
             if (ch == '\\') {
                 escape = !escape;
@@ -191,7 +187,6 @@ public:
                 }
                 curlyBraceOpen = !escape;
             }
-
             if (ch == '}' && !escape) {
                 curlyBraceOpen = false;
             }
@@ -200,27 +195,29 @@ public:
     }
 
 private:
-    bool startsWith(const std::string &str, const std::string &prefix) const { return str.rfind(prefix, 0) == 0; }
-
-    std::string sortString(std::string str) {
+    bool startsWith(const std::string &str,
+        const std::string &prefix) const { return str.rfind(prefix, 0) == 0; }
+    std::string sortString(std::string str)
+    {
         std::sort(str.begin(), str.end());
         return str;
     }
-
-    std::string replaceChars(const std::string &str) {
+    std::string replaceChars(const std::string &str)
+    {
         std::string newStr = str;
         std::replace(newStr.begin(), newStr.end(), '_', 'A');
         std::replace(newStr.begin(), newStr.end(), '-', 'a');
         return newStr;
     }
-
-    std::string replaceCharsBack(const std::string &str) {
+    std::string replaceCharsBack(const std::string &str)
+    {
         std::string newStr = str;
         std::replace(newStr.begin(), newStr.end(), 'A', '_');
         std::replace(newStr.begin(), newStr.end(), 'a', '-');
         return newStr;
     }
-    std::string join(const std::vector<std::string> &strings) {
+    std::string join(const std::vector<std::string> &strings)
+    {
         std::string result;
         for (const auto &str : strings) {
             result += str; // 将所有块连接成一个字符串
@@ -228,4 +225,5 @@ private:
         return result;
     }
 };
-} // namespace TinpMask
+} // namespace TinpMask
+#endif

package/harmony/text_input_mask/src/main/cpp/common/Mask.h

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef MASK_H
+#define MASK_H
 #pragma once
 #include <string>
 #include <vector>
@@ -15,7 +16,6 @@
 #include "model/State.h"
 
 namespace TinpMask {
-
 class Mask {
 protected:
     std::vector<Notation> customNotations;
@@ -28,27 +28,33 @@ private:
 
 public:
     // 主构造函数
-    Mask(const std::string &format, const std::vector<Notation> &customNotations) : customNotations(customNotations) {
+    Mask(const std::string &format, const std::vector<Notation> &customNotations) : customNotations(customNotations)
+    {
         this->format = format;
         this->customNotations = customNotations;
         this->initialState = Compiler(customNotations).compile(format);
     }
 
     // 便利构造函数
-    Mask(const std::string &format) : Mask(format, {}) { // 调用主构造函数，传入空的 customNotations
+    Mask(const std::string &format) : Mask(format, {})
+    { // 调用主构造函数，传入空的 customNotations
         std::vector<Notation> emptyVector;
         this->format = format;
         this->customNotations = emptyVector;
         this->initialState = Compiler(this->customNotations).compile(this->format);
     }
 
+    bool hasSameCustomNotations(const std::vector<Notation> &targetNotations) const
+    {
+        return this->customNotations == targetNotations;
+    }
 
     class MaskFactory {
     public:
         static std::unordered_map<std::string, std::shared_ptr<Mask>> maskCache;
 
     public:
-        /**
+        /* *
          * Factory constructor.
          *
          * Operates over own ``Mask`` cache where initialized ``Mask`` objects are stored under
@@ -58,9 +64,10 @@ public:
          * doesn't exist in cache, the object is constructed, cached and returned.
          */
         static std::shared_ptr<Mask> getOrCreate(const std::string &format,
-                                                 const std::vector<Notation> &customNotations) {
+            const std::vector<Notation> &customNotations)
+        {
             auto cachedMask = maskCache.find(format);
-            if (cachedMask == maskCache.end()) {
+            if (cachedMask == maskCache.end() || !cachedMask->second->hasSameCustomNotations(customNotations)) {
                 auto newMask = std::make_shared<Mask>(format, customNotations);
                 maskCache[format] = newMask;
                 return newMask;
@@ -68,7 +75,7 @@ public:
             return cachedMask->second;
         }
 
-        /**
+        /* *
          * Check your mask format is valid.
          *
          * @param format mask format.
@@ -77,7 +84,8 @@ public:
          * @returns `true` if this format coupled with custom notations will compile into a working ``Mask`` object.
          * Otherwise `false`.
          */
-        static bool isValid(const std::string &format, const std::vector<Notation> &customNotations) {
+        static bool isValid(const std::string &format, const std::vector<Notation> &customNotations)
+        {
             try {
                 Mask(format, customNotations);
                 return true;
@@ -86,14 +94,15 @@ public:
             }
         }
     };
-    /**
+    /* *
      * Apply mask to the user input string.
      *
      * @param text user input string with current cursor position
      *
      * @returns Formatted text with extracted value an adjusted cursor position.
      */
-    virtual Result apply(const CaretString &text) {
+    virtual Result apply(const CaretString &text)
+    {
         auto iterator = makeIterator(text); // Assume this function is defined
 
         int affinity = 0;
@@ -109,7 +118,6 @@ public:
         char character = iterator->next();
         while (character != '\0') {
             auto next = state->accept(character);
-
             if (next != nullptr) {
                 if (deletionAffectsCaret) {
                     auto opt = state->autocomplete();
@@ -152,9 +160,9 @@ public:
 
         while (text.caretGravity->autocomplete() && insertionAffectsCaret) {
             auto next = state->autocomplete();
-            if (next == nullptr)
+            if (next == nullptr) {
                 break;
-
+            }
             state = next->state;
             if (next->insert == '\0') {
                 modifiedString += "";
@@ -194,34 +202,35 @@ public:
         std::string tailPlaceholder = appendPlaceholder(tailState.get(), tail); // Assume this function is defined
 
         return Result(CaretString(modifiedString, modifiedCaretPosition, text.caretGravity), extractedValue, affinity,
-                      noMandatoryCharactersLeftAfterState(state.get()), // Assume this function is defined
-                      tailPlaceholder);
+            noMandatoryCharactersLeftAfterState(state.get()), tailPlaceholder);
     }
 
-
 public:
-    std::shared_ptr<CaretStringIterator> makeIterator(const CaretString &text) const {
+    std::shared_ptr<CaretStringIterator> makeIterator(const CaretString &text) const
+    {
         return std::make_shared<CaretStringIterator>(text);
     }
-
-    /**
+    /* *
      * Generate placeholder.
      *
      * @return Placeholder string.
      */
 public:
-    std::string placeholder() { return appendPlaceholder(initialState.get(), ""); }
-    /**
+    std::string placeholder()
+    {
+        return appendPlaceholder(initialState.get(), "");
+    }
+    /* *
      * Minimal length of the text inside the field to fill all mandatory characters in the mask.
      *
      * @return Minimal satisfying count of characters inside the text field.
      */
 public:
-    int acceptableTextLength() {
+    int acceptableTextLength()
+    {
         std::shared_ptr<State> state = std::move(initialState);
         ;
         int length = 0;
-
         while (state != nullptr && dynamic_cast<EOLState *>(state.get()) == nullptr) {
             if (dynamic_cast<FixedState *>(state.get()) != nullptr ||
                 dynamic_cast<FreeState *>(state.get()) != nullptr ||
@@ -230,18 +239,16 @@ public:
             }
             state = state->child; // 移动到下一个子状态
         }
-
         return length;
     }
-
-
-    /**
+    /* *
      * Maximal length of the text inside the field.
      *
      * @return Total available count of mandatory and optional characters inside the text field.
      */
 public:
-    int totalTextLength() const {
+    int totalTextLength() const
+    {
         std::shared_ptr<State> state = initialState;
         ;
         int length = 0;
@@ -255,16 +262,16 @@ public:
             }
             state = state->child; // 移动到下一个子状态
         }
-
         return length;
     }
-    /**
+    /* *
      * Minimal length of the extracted value with all mandatory characters filled.\
      *
      * @return Minimal satisfying count of characters in extracted value.
      */
 public:
-    int acceptableValueLength() const {
+    int acceptableValueLength() const
+    {
         std::shared_ptr<State> state = initialState;
         int length = 0;
         while (state != nullptr && dynamic_cast<EOLState *>(state.get()) == nullptr) {
@@ -274,16 +281,16 @@ public:
             }
             state = state->child; // 移动到下一个子状态
         }
-
         return length;
     }
-    /**
+    /* *
      * Maximal length of the extracted value.
      *
      * @return Total available count of mandatory and optional characters for extracted value.
      */
 public:
-    int totalValueLength() const {
+    int totalValueLength() const
+    {
         std::shared_ptr<State> state = initialState;
         int length = 0;
         while (state != nullptr && dynamic_cast<EOLState *>(state.get()) == nullptr) {
@@ -298,7 +305,8 @@ public:
     }
 
 private:
-    std::string appendPlaceholder(State *state, const std::string &placeholder) const {
+    std::string appendPlaceholder(State *state, const std::string &placeholder) const
+    {
         if (state == nullptr) {
             return placeholder;
         }
@@ -334,7 +342,6 @@ private:
                 return placeholder; // 未知类型，返回原始 placeholder
             }
         }
-
         if (auto valueState = dynamic_cast<ValueState *>(state)) {
             if (!state) {
                 return placeholder; // 如果 state 为 nullptr，直接返回原始 placeholder
@@ -351,19 +358,17 @@ private:
                 if (customValueState->type.get()) {
                     auto customStateType = dynamic_cast<ValueState::Custom *>(customValueState->type.get());
                     return appendPlaceholder(state->child.get(), placeholder + customStateType->character);
-                }else {
-                    throw FormatError("appendPlaceholder customValueState type is null"); // 未找到匹配项，抛出异常 
+                } else {
+                    throw FormatError("appendPlaceholder customValueState type is null");
                 }
-
             } else {
-                return placeholder; // 未知类型，返回原始 placeholder
+                return placeholder;
             }
         }
-
         return placeholder;
     }
-
-    bool noMandatoryCharactersLeftAfterState(State *state) const {
+    bool noMandatoryCharactersLeftAfterState(State *state) const
+    {
         if (dynamic_cast<EOLState *>(state)) {
             return true;
         } else if (auto valueState = dynamic_cast<ValueState *>(state)) {
@@ -375,4 +380,5 @@ private:
         }
     }
 };
-} // namespace TinpMask
+} // namespace TinpMask
+#endif

package/harmony/text_input_mask/src/main/cpp/common/RTLMask.h

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef RTLMASK_H
+#define RTLMASK_H
 #pragma once
 #include "common/Mask.h"
 #include "common/model/CaretString.h"
@@ -13,11 +14,12 @@ namespace TinpMask {
 class RTLMask : public Mask   {
     
 public:
-     static std::unordered_map<std::string, std::shared_ptr<RTLMask>> cache ;
+    static std::unordered_map<std::string, std::shared_ptr<RTLMask>> cache ;
     RTLMask(const std::string& format, const std::vector<Notation>& customNotations)
         : Mask(reversedFormat(format), customNotations) {}
-
-    static std::shared_ptr<RTLMask> getOrCreate(const std::string& format, const std::vector<Notation>& customNotations) {
+    static std::shared_ptr<RTLMask> getOrCreate(const std::string& format,
+        const std::vector<Notation>& customNotations)
+    {
         std::string reversed = reversedFormat(format);
         auto it = cache.find(reversed);
         if (it != cache.end()) {
@@ -29,40 +31,35 @@ public:
         cache[reversed] = newMask;
         return newMask;
     }
-
-    Result apply(const CaretString& text) override {
+    Result apply(const CaretString& text) override
+    {
         return Mask::apply(text.reversed()).reversed(); // Assuming the Result class has a reversed method
     }
-    
-
 private:
-   
-
-    static std::string reversedFormat(const std::string& format) {
+    static constexpr size_t ESCAPED_BRACKET_LENGTH = 2;
+    static std::string reversedFormat(const std::string& format)
+    {
         std::string reversed = std::string(format.rbegin(), format.rend());
-        
-        // Replace logic (equivalent to Kotlin's replace)
         size_t pos = 0;
         while ((pos = reversed.find("\\[", pos)) != std::string::npos) {
-            reversed.replace(pos, 2, "\\");
-            pos += 1; // Advance position to prevent infinite loop
+            reversed.replace(pos, ESCAPED_BRACKET_LENGTH, "\\");
+            pos += 1;
         }
         pos = 0;
         while ((pos = reversed.find("]\\", pos)) != std::string::npos) {
-            reversed.replace(pos, 2, "\\[");
+            reversed.replace(pos, ESCAPED_BRACKET_LENGTH, "\\[");
             pos += 1;
         }
         pos = 0;
         while ((pos = reversed.find("\\{", pos)) != std::string::npos) {
-            reversed.replace(pos, 2, "\\}");
+            reversed.replace(pos, ESCAPED_BRACKET_LENGTH, "\\}");
             pos += 1;
         }
         pos = 0;
         while ((pos = reversed.find("}\\", pos)) != std::string::npos) {
-            reversed.replace(pos, 2, "\\{");
+            reversed.replace(pos, ESCAPED_BRACKET_LENGTH, "\\{");
             pos += 1;
         }
-
         // Map logic for brackets
         for (char& ch : reversed) {
             switch (ch) {
@@ -76,4 +73,5 @@ private:
         return reversed;
     }
 };
-}
+}
+#endif

package/harmony/text_input_mask/src/main/cpp/common/model/AffinityCalculationStrategy.h

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef AFFINITYCALCULATIONSTRATEGY_H
+#define AFFINITYCALCULATIONSTRATEGY_H
 #pragma once
 #include <string>
 #include <stdexcept>
@@ -18,32 +19,34 @@ enum class AffinityCalculationStrategy { WHOLE_STRING, PREFIX, CAPACITY, EXTRACT
 class AffinityCalculator {
 public:
     static int calculateAffinityOfMask(AffinityCalculationStrategy strategy,  Mask &mask,
-                                       const CaretString &text) {
+        const CaretString &text)
+    {
         switch (strategy) {
-        case AffinityCalculationStrategy::WHOLE_STRING:
-            return mask.apply(text).affinity;
+            case AffinityCalculationStrategy::WHOLE_STRING:
+                return mask.apply(text).affinity;
 
-        case AffinityCalculationStrategy::PREFIX:
-            return prefixIntersection(mask.apply(text).formattedText.string, text.string).length();
+            case AffinityCalculationStrategy::PREFIX:
+                return prefixIntersection(mask.apply(text).formattedText.string, text.string).length();
 
-        case AffinityCalculationStrategy::CAPACITY:
-            return text.string.length() > mask.totalTextLength() ? std::numeric_limits<int>::min()
-                                                                 : text.string.length() - mask.totalTextLength();
+            case AffinityCalculationStrategy::CAPACITY:
+                return text.string.length() > mask.totalTextLength() ? std::numeric_limits<int>::min()
+                    : text.string.length() - mask.totalTextLength();
 
-        case AffinityCalculationStrategy::EXTRACTED_VALUE_CAPACITY: {
-            const auto &extractedValue = mask.apply(text).extractedValue;
-            return extractedValue.length() > mask.totalValueLength()
-                       ? std::numeric_limits<int>::min()
-                       : extractedValue.length() - mask.totalValueLength();
-        }
-        default:
-            throw std::invalid_argument("Unknown AffinityCalculationStrategy");
+            case AffinityCalculationStrategy::EXTRACTED_VALUE_CAPACITY: {
+                const auto &extractedValue = mask.apply(text).extractedValue;
+                return extractedValue.length() > mask.totalValueLength()
+                    ? std::numeric_limits<int>::min()
+                    : extractedValue.length() - mask.totalValueLength();
+            }
+            default:
+                throw std::invalid_argument("Unknown AffinityCalculationStrategy");
         }
     }
 
 private:
     // Helper function to find prefix intersection
-    static std::string prefixIntersection(const std::string &str1, const std::string &str2) {
+    static std::string prefixIntersection(const std::string &str1, const std::string &str2)
+    {
         size_t endIndex = 0;
         while (endIndex < str1.length() && endIndex < str2.length()) {
             if (str1[endIndex] == str2[endIndex]) {
@@ -55,4 +58,5 @@ private:
         return str1.substr(0, endIndex);
     }
 };
-} // namespace TinpMask
+} // namespace TinpMask
+#endif

package/harmony/text_input_mask/src/main/cpp/common/model/CaretString.h

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef CARETSTRING_H
+#define CARETSTRING_H
 #pragma once
 #include <string>
 #include <memory>
@@ -26,7 +27,7 @@ public:
     // 向前的光标重力
     class Forward : public CaretGravity {
     public:
-        Forward(bool autoCompleteValue) : autocompleteValue(autoCompleteValue) {}
+        explicit Forward(bool autoCompleteValue) : autocompleteValue(autoCompleteValue) {}
 
         bool autocomplete() const override { return autocompleteValue; }
 
@@ -37,7 +38,7 @@ public:
     // 向后的光标重力
     class Backward : public CaretGravity {
     public:
-        Backward(bool autoSkipValue) : autoskipValue(autoSkipValue) {}
+        explicit Backward(bool autoSkipValue) : autoskipValue(autoSkipValue) {}
 
         bool autoskip() const override { return autoskipValue; }
 
@@ -51,26 +52,23 @@ public:
         : string(str), caretPosition(caretPos), caretGravity(caretGrav) {}
 
     // 反转字符串并返回新的 CaretString 对象
-    CaretString reversed() const {
+    CaretString reversed() const
+    {
         // 创建一个反转后的字符串
         std::string reversedStr(string.rbegin(), string.rend());
         // 计算新的 caretPosition
         int newCaretPos = string.length() - caretPosition;
         return CaretString(reversedStr, newCaretPos, caretGravity);
     }
-
-    // 获取字符串
     const std::string &getString() const { return string; }
     // 获取光标位置
     int getCaretPosition() const { return caretPosition; }
     // 获取光标重力
     std::shared_ptr<CaretGravity> getCaretGravity() const { return caretGravity; }
-
-
 public:
-    std::string string;                         // 字符串内容
-    int caretPosition;                          // 光标位置
-    std::shared_ptr<CaretGravity> caretGravity; // 光标重力
+    std::string string;
+    int caretPosition;
+    std::shared_ptr<CaretGravity> caretGravity;
 };
-
-} // namespace TinpMask
+} // namespace TinpMask
+#endif