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

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

@@ -1,79 +1,79 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
- * Use of this source code is governed by a MIT license that can be
- * found in the LICENSE file.
- */
-
-#pragma once
-#include "common/Mask.h"
-#include "common/model/CaretString.h"
-#include "common/model/Notation.h"
-#include "common/model/common.h"
-namespace TinpMask {
-class RTLMask : public Mask   {
-    
-public:
-     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) {
-        std::string reversed = reversedFormat(format);
-        auto it = cache.find(reversed);
-        if (it != cache.end()) {
-            return it->second; // Return cached instance
-        }
-
-        // Create new instance and cache it
-        auto newMask = std::make_shared<RTLMask>(format, customNotations);
-        cache[reversed] = newMask;
-        return newMask;
-    }
-
-    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) {
-        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
-        }
-        pos = 0;
-        while ((pos = reversed.find("]\\", pos)) != std::string::npos) {
-            reversed.replace(pos, 2, "\\[");
-            pos += 1;
-        }
-        pos = 0;
-        while ((pos = reversed.find("\\{", pos)) != std::string::npos) {
-            reversed.replace(pos, 2, "\\}");
-            pos += 1;
-        }
-        pos = 0;
-        while ((pos = reversed.find("}\\", pos)) != std::string::npos) {
-            reversed.replace(pos, 2, "\\{");
-            pos += 1;
-        }
-
-        // Map logic for brackets
-        for (char& ch : reversed) {
-            switch (ch) {
-                case '[': ch = ']'; break;
-                case ']': ch = '['; break;
-                case '{': ch = '}'; break;
-                case '}': ch = '{'; break;
-                default: break;
-            }
-        }
-        return reversed;
-    }
-};
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+#include "common/Mask.h"
+#include "common/model/CaretString.h"
+#include "common/model/Notation.h"
+#include "common/model/common.h"
+namespace TinpMask {
+class RTLMask : public Mask   {
+    
+public:
+     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) {
+        std::string reversed = reversedFormat(format);
+        auto it = cache.find(reversed);
+        if (it != cache.end()) {
+            return it->second; // Return cached instance
+        }
+
+        // Create new instance and cache it
+        auto newMask = std::make_shared<RTLMask>(format, customNotations);
+        cache[reversed] = newMask;
+        return newMask;
+    }
+
+    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) {
+        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
+        }
+        pos = 0;
+        while ((pos = reversed.find("]\\", pos)) != std::string::npos) {
+            reversed.replace(pos, 2, "\\[");
+            pos += 1;
+        }
+        pos = 0;
+        while ((pos = reversed.find("\\{", pos)) != std::string::npos) {
+            reversed.replace(pos, 2, "\\}");
+            pos += 1;
+        }
+        pos = 0;
+        while ((pos = reversed.find("}\\", pos)) != std::string::npos) {
+            reversed.replace(pos, 2, "\\{");
+            pos += 1;
+        }
+
+        // Map logic for brackets
+        for (char& ch : reversed) {
+            switch (ch) {
+                case '[': ch = ']'; break;
+                case ']': ch = '['; break;
+                case '{': ch = '}'; break;
+                case '}': ch = '{'; break;
+                default: break;
+            }
+        }
+        return reversed;
+    }
+};
 }

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

@@ -1,58 +1,58 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
- * Use of this source code is governed by a MIT license that can be
- * found in the LICENSE file.
- */
-
-#pragma once
-#include <string>
-#include <stdexcept>
-#include <limits>
-#include "../Mask.h"     // 确保包含 Mask 头文件
-#include "CaretString.h" // 确保包含 CaretString 头文件
-
-namespace TinpMask {
-
-enum class AffinityCalculationStrategy { WHOLE_STRING, PREFIX, CAPACITY, EXTRACTED_VALUE_CAPACITY };
-
-class AffinityCalculator {
-public:
-    static int calculateAffinityOfMask(AffinityCalculationStrategy strategy,  Mask &mask,
-                                       const CaretString &text) {
-        switch (strategy) {
-        case AffinityCalculationStrategy::WHOLE_STRING:
-            return mask.apply(text).affinity;
-
-        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::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) {
-        size_t endIndex = 0;
-        while (endIndex < str1.length() && endIndex < str2.length()) {
-            if (str1[endIndex] == str2[endIndex]) {
-                endIndex += 1;
-            } else {
-                return str1.substr(0, endIndex);
-            }
-        }
-        return str1.substr(0, endIndex);
-    }
-};
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+#include <string>
+#include <stdexcept>
+#include <limits>
+#include "../Mask.h"     // 确保包含 Mask 头文件
+#include "CaretString.h" // 确保包含 CaretString 头文件
+
+namespace TinpMask {
+
+enum class AffinityCalculationStrategy { WHOLE_STRING, PREFIX, CAPACITY, EXTRACTED_VALUE_CAPACITY };
+
+class AffinityCalculator {
+public:
+    static int calculateAffinityOfMask(AffinityCalculationStrategy strategy,  Mask &mask,
+                                       const CaretString &text) {
+        switch (strategy) {
+        case AffinityCalculationStrategy::WHOLE_STRING:
+            return mask.apply(text).affinity;
+
+        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::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) {
+        size_t endIndex = 0;
+        while (endIndex < str1.length() && endIndex < str2.length()) {
+            if (str1[endIndex] == str2[endIndex]) {
+                endIndex += 1;
+            } else {
+                return str1.substr(0, endIndex);
+            }
+        }
+        return str1.substr(0, endIndex);
+    }
+};
 } // namespace TinpMask

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

@@ -1,76 +1,76 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
- * Use of this source code is governed by a MIT license that can be
- * found in the LICENSE file.
- */
-
-#pragma once
-#include <string>
-#include <memory>
-
-namespace TinpMask {
-
-class CaretString {
-    // 光标重力基类
-public:
-    class CaretGravity {
-    public:
-        virtual ~CaretGravity() = default; // 虚析构函数
-
-        // 获取自动完成值
-        virtual bool autocomplete() const { return false; }
-        // 获取自动跳过值
-        virtual bool autoskip() const { return false; }
-    };
-
-    // 向前的光标重力
-    class Forward : public CaretGravity {
-    public:
-        Forward(bool autoCompleteValue) : autocompleteValue(autoCompleteValue) {}
-
-        bool autocomplete() const override { return autocompleteValue; }
-
-    private:
-        bool autocompleteValue; // 自动完成值
-    };
-
-    // 向后的光标重力
-    class Backward : public CaretGravity {
-    public:
-        Backward(bool autoSkipValue) : autoskipValue(autoSkipValue) {}
-
-        bool autoskip() const override { return autoskipValue; }
-
-    private:
-        bool autoskipValue; // 自动跳过值
-    };
-
-public:
-    // 构造函数
-    CaretString(const std::string &str, int caretPos, std::shared_ptr<CaretGravity> caretGrav)
-        : string(str), caretPosition(caretPos), caretGravity(caretGrav) {}
-
-    // 反转字符串并返回新的 CaretString 对象
-    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; // 光标重力
-};
-
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+#include <string>
+#include <memory>
+
+namespace TinpMask {
+
+class CaretString {
+    // 光标重力基类
+public:
+    class CaretGravity {
+    public:
+        virtual ~CaretGravity() = default; // 虚析构函数
+
+        // 获取自动完成值
+        virtual bool autocomplete() const { return false; }
+        // 获取自动跳过值
+        virtual bool autoskip() const { return false; }
+    };
+
+    // 向前的光标重力
+    class Forward : public CaretGravity {
+    public:
+        Forward(bool autoCompleteValue) : autocompleteValue(autoCompleteValue) {}
+
+        bool autocomplete() const override { return autocompleteValue; }
+
+    private:
+        bool autocompleteValue; // 自动完成值
+    };
+
+    // 向后的光标重力
+    class Backward : public CaretGravity {
+    public:
+        Backward(bool autoSkipValue) : autoskipValue(autoSkipValue) {}
+
+        bool autoskip() const override { return autoskipValue; }
+
+    private:
+        bool autoskipValue; // 自动跳过值
+    };
+
+public:
+    // 构造函数
+    CaretString(const std::string &str, int caretPos, std::shared_ptr<CaretGravity> caretGrav)
+        : string(str), caretPosition(caretPos), caretGravity(caretGrav) {}
+
+    // 反转字符串并返回新的 CaretString 对象
+    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; // 光标重力
+};
+
 } // namespace TinpMask

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

@@ -1,58 +1,58 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
- * Use of this source code is governed by a MIT license that can be
- * found in the LICENSE file.
- */
-
-#pragma once
-#include <string>
-#include <memory>
-#include <string>
-#include <memory>
-#include "CaretString.h"
-
-namespace TinpMask {
-
-class CaretStringIterator {
-protected:
-    CaretString caretString; // 关联的 CaretString 对象
-    int currentIndex;        // 当前索引
-
-public:
-    // 构造函数
-    CaretStringIterator(const CaretString &caretStr, int index = 0) : caretString(caretStr), currentIndex(index) {}
-
-    // 插入是否影响光标位置
-    virtual bool insertionAffectsCaret() {
-
-        if (dynamic_cast<CaretString::Backward *>(caretString.caretGravity.get())) {
-            return currentIndex < caretString.getCaretPosition();
-        } else if (dynamic_cast<CaretString::Forward *>(caretString.caretGravity.get())) {
-            return currentIndex <= caretString.getCaretPosition() ||
-                   (currentIndex == 0 && caretString.getCaretPosition() == 0);
-        }
-        return false;
-    }
-
-    // 删除是否影响光标位置
-    virtual bool deletionAffectsCaret() { return currentIndex < caretString.getCaretPosition(); }
-
-    /**
-     * 遍历 CaretString.string
-     * @postcondition: 迭代器位置移到下一个符号。
-     * @returns 当前符号。如果迭代器到达字符串末尾，返回 nullptr。
-     */
-    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
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+#include <string>
+#include <memory>
+#include <string>
+#include <memory>
+#include "CaretString.h"
+
+namespace TinpMask {
+
+class CaretStringIterator {
+protected:
+    CaretString caretString; // 关联的 CaretString 对象
+    int currentIndex;        // 当前索引
+
+public:
+    // 构造函数
+    CaretStringIterator(const CaretString &caretStr, int index = 0) : caretString(caretStr), currentIndex(index) {}
+
+    // 插入是否影响光标位置
+    virtual bool insertionAffectsCaret() {
+
+        if (dynamic_cast<CaretString::Backward *>(caretString.caretGravity.get())) {
+            return currentIndex < caretString.getCaretPosition();
+        } else if (dynamic_cast<CaretString::Forward *>(caretString.caretGravity.get())) {
+            return currentIndex <= caretString.getCaretPosition() ||
+                   (currentIndex == 0 && caretString.getCaretPosition() == 0);
+        }
+        return false;
+    }
+
+    // 删除是否影响光标位置
+    virtual bool deletionAffectsCaret() { return currentIndex < caretString.getCaretPosition(); }
+
+    /**
+     * 遍历 CaretString.string
+     * @postcondition: 迭代器位置移到下一个符号。
+     * @returns 当前符号。如果迭代器到达字符串末尾，返回 nullptr。
+     */
+    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

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

@@ -1,25 +1,25 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
- * Use of this source code is governed by a MIT license that can be
- * found in the LICENSE file.
- */
-
-#pragma once
-#include <memory>
-#include "State.h"
-
-namespace TinpMask {
-
-class State;
-class Next {
-public:
-    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) {}
-};
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+#include <memory>
+#include "State.h"
+
+namespace TinpMask {
+
+class State;
+class Next {
+public:
+    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

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

@@ -1,25 +1,25 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
- * Use of this source code is governed by a MIT license that can be
- * found in the LICENSE file.
- */
-
-#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) {}
-
-    // 成员变量
-    char character;           // 单个字符作为字符串
-    std::string characterSet; // 字符集
-    bool isOptional;          // 是否可选
-
-    // 其他方法和成员可以根据需要添加
-};
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#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) {}
+
+    // 成员变量
+    char character;           // 单个字符作为字符串
+    std::string characterSet; // 字符集
+    bool isOptional;          // 是否可选
+
+    // 其他方法和成员可以根据需要添加
+};
 } // namespace TinpMask