@react-native-ohos/react-native-text-input-mask 3.1.6-rc.4 → 3.1.6-rc.6

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,21 +28,24 @@ 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 {
+    bool hasSameCustomNotations(const std::vector<Notation> &targetNotations) const
+    {
         return this->customNotations == targetNotations;
     }
 
@@ -51,7 +54,7 @@ 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
@@ -61,7 +64,8 @@ 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() || !cachedMask->second->hasSameCustomNotations(customNotations)) {
                 auto newMask = std::make_shared<Mask>(format, customNotations);
@@ -71,7 +75,7 @@ public:
             return cachedMask->second;
         }
 
-        /**
+        /* *
          * Check your mask format is valid.
          *
          * @param format mask format.
@@ -80,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;
@@ -89,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;
@@ -112,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();
@@ -155,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 += "";
@@ -197,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 ||
@@ -233,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;
@@ -258,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) {
@@ -277,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) {
@@ -301,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;
         }
@@ -337,7 +342,6 @@ private:
                 return placeholder; // 未知类型，返回原始 placeholder
             }
         }
-
         if (auto valueState = dynamic_cast<ValueState *>(state)) {
             if (!state) {
                 return placeholder; // 如果 state 为 nullptr，直接返回原始 placeholder
@@ -354,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)) {
@@ -378,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

package/harmony/text_input_mask/src/main/cpp/common/model/CaretStringIterator.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 CARETSTRINGITERATOR_H
+#define CARETSTRINGITERATOR_H
 #pragma once
 #include <string>
 #include <memory>
@@ -20,11 +21,12 @@ protected:
 
 public:
     // 构造函数
-    CaretStringIterator(const CaretString &caretStr, int index = 0) : caretString(caretStr), currentIndex(index) {}
+    explicit CaretStringIterator(const CaretString &caretStr, int index = 0) : caretString(caretStr),
+        currentIndex(index) {}
 
     // 插入是否影响光标位置
-    virtual bool insertionAffectsCaret() {
-
+    virtual bool insertionAffectsCaret()
+    {
         if (dynamic_cast<CaretString::Backward *>(caretString.caretGravity.get())) {
             return currentIndex < caretString.getCaretPosition();
         } else if (dynamic_cast<CaretString::Forward *>(caretString.caretGravity.get())) {
@@ -33,26 +35,23 @@ public:
         }
         return false;
     }
-
     // 删除是否影响光标位置
     virtual bool deletionAffectsCaret() { return currentIndex < caretString.getCaretPosition(); }
-
     /**
      * 遍历 CaretString.string
      * @postcondition: 迭代器位置移到下一个符号。
      * @returns 当前符号。如果迭代器到达字符串末尾，返回 nullptr。
      */
-    virtual char next() {
+    virtual char next()
+    {
         if (currentIndex >= caretString.getString().length()) {
             return '\0'; // 返回空指针表示到达字符串末尾
         }
-
 //         char *charPtr = new char;                         // 创建一个字符指针
         auto charPtr = caretString.getString()[currentIndex]; // 获取当前字符
         currentIndex += 1;                                // 移动到下一个索引
         return charPtr;                                   // 返回当前字符
     }
 };
-
-
 } // namespace TinpMask
+#endif

package/harmony/text_input_mask/src/main/cpp/common/model/Next.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 NEXT_H
+#define NEXT_H
 #pragma once
 #include <memory>
 #include "State.h"
@@ -13,13 +14,12 @@ namespace TinpMask {
 class State;
 class Next {
 public:
-    std::shared_ptr<State> state; // 存储状态的智能指针
-    char insert;                  // 可插入的字符
-    bool pass;                    // 是否通过
-    char value;                   // 值字符，可选
-
-    // 构造函数
+    std::shared_ptr<State> state;
+    char insert;
+    bool pass;
+    char value;
     Next(std::shared_ptr<State> state, char insert, bool pass, char value)
         : state(state), insert(insert), pass(pass), value(value) {}
 };
-} // namespace TinpMask
+}
+#endif

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

@@ -3,28 +3,28 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef NOTATION_H
+#define NOTATION_H
 #pragma once
 #include <string>
 
 namespace TinpMask {
-
 class Notation {
 public:
     // 构造函数
     Notation(const char character, const std::string &characterSet, bool isOptional)
-        : character(character), characterSet(characterSet), isOptional(isOptional) {}
-
+        : character(character), characterSet(characterSet), isOptional(isOptional)
+    {}
     // 成员变量
     char character;           // 单个字符作为字符串
     std::string characterSet; // 字符集
     bool isOptional;          // 是否可选
-
-    // 其他方法和成员可以根据需要添加
-     bool operator==(const Notation& other) const {
-        return (this->character == other.character) &&
-               (this->characterSet == other.characterSet) &&
-               (this->isOptional == other.isOptional);
+                              // 其他方法和成员可以根据需要添加
+    bool operator == (const Notation &other) const
+    {
+        return (this->character == other.character) && (this->characterSet == other.characterSet) &&
+            (this->isOptional == other.isOptional);
     }
 };
-} // namespace TinpMask
+} // namespace TinpMask
+#endif

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

@@ -14,8 +14,8 @@ class RTLCaretStringIterator : public CaretStringIterator {
 public:
     RTLCaretStringIterator(const CaretString& caretString)
         : CaretStringIterator(caretString) {}
-
-    bool insertionAffectsCaret()  {
+    bool insertionAffectsCaret()
+    {
         return currentIndex <= caretString.caretPosition;
     }
 };