@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/RNTextInputMask.h

@@ -1,93 +1,93 @@
-/*
- * 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.
- */
-
-/**
- * This code was generated by "react-native codegen-harmony"
- *
- * Do not edit this file as changes may cause incorrect behavior and will be
- * lost once the code is regenerated.
- *
- * @generatorVersion: 1
- */
-#pragma once
-
-#include "RNOH/ArkTSTurboModule.h"
-#include "RNOH/arkui/NativeNodeApi.h"
-#include "RNOH/arkui/TextInputNode.h"
-#include "common/model/Notation.h"
-#include "common/RTLMask.h"
-#include "common/model/AffinityCalculationStrategy.h"
-using namespace rnoh;
-using namespace facebook;
-using namespace TinpMask;
-
-void myEventReceiver(ArkUI_NodeEvent *event);
-
-namespace rnoh {
-
-class RNTextInputMask;
-
-struct MaskParams {
-    std::string mask;                 // mask的格式
-    std::string value;                // 待mask的值
-    std::optional<bool> autocomplete; // 布尔值，表示是否自动完成
-    MaskParams() = default;
-    MaskParams(const std::string &m, const std::string &v, std::optional<bool> autoComplete = std::nullopt)
-        : mask(m), value(v), autocomplete(autoComplete) {} // 构造函数
-    MaskParams &operator=(const MaskParams &input) {
-        this->mask = input.mask;
-        this->value = input.value;
-        this->autocomplete = input.autocomplete;
-        return *this;
-    }
-};
-
-struct MaskOptions {
-    std::optional<std::vector<std::string>> affineFormats;  // 可选的字符串数组
-    std::optional<std::vector<Notation>> customNotations;   // 可选的 Notation 数组
-    std::optional<std::string> affinityCalculationStrategy; // 可选字符串
-    std::optional<bool> autocomplete;                       // 可选布尔值
-    std::optional<bool> autoskip;                           // 可选布尔值
-    std::optional<bool> rightToLeft;                        // 可选布尔值
-
-    MaskOptions()
-        : affineFormats(std::vector<std::string>()), customNotations(std::vector<Notation>()),
-          affinityCalculationStrategy(std::nullopt), autocomplete(true), autoskip(false), rightToLeft(false) {}
-    MaskOptions(const std::vector<std::string> &formats, const std::vector<Notation> &notations,
-                const std::string &strategy, bool autoComp, bool autoSkip, bool rtl)
-        : affineFormats(formats), customNotations(notations),
-          affinityCalculationStrategy(strategy.empty() ? std::make_optional("WHOLE_STRING") : std::make_optional(strategy)),
-          autocomplete(autoComp), autoskip(autoSkip), rightToLeft(rtl) {}
-};
-
-typedef struct {
-    ArkUI_NodeHandle data;
-    MaskOptions maskOptions;
-    std::string primaryFormat;
-    int node;
-    std::string lastInputText;
-    RNTextInputMask *instance;
-} UserData;
-
-class JSI_EXPORT RNTextInputMask : public ArkTSTurboModule {
-public:
-    RNTextInputMask(const ArkTSTurboModule::Context ctx, const std::string name);
-    void setMask(int reactNode, std::string primaryFormat, MaskOptions options);
-    jsi::Value mask(std::string mask, std::string value, bool autocomplete);
-    jsi::Value unmask(std::string mask, std::string value, bool autocomplete);
-    jsi::Value unmaskWithRightToLeft(std::string mask, std::string value, bool autocomplete, bool rightToLeft);
-    jsi::Runtime *grt = nullptr;
-    std::shared_ptr<Mask> pickMask(const CaretString &text, MaskOptions maskOptions, std::string primaryMask);
-
-    // 释放资源
-    ~RNTextInputMask();
-
-private:
-    std::unordered_set<UserData *> m_userDatas;
-};
-
-
-} // namespace rnoh
+/*
+ * 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.
+ */
+
+/**
+ * This code was generated by "react-native codegen-harmony"
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be
+ * lost once the code is regenerated.
+ *
+ * @generatorVersion: 1
+ */
+#pragma once
+
+#include "RNOH/ArkTSTurboModule.h"
+#include "RNOH/arkui/NativeNodeApi.h"
+#include "RNOH/arkui/TextInputNode.h"
+#include "common/model/Notation.h"
+#include "common/RTLMask.h"
+#include "common/model/AffinityCalculationStrategy.h"
+using namespace rnoh;
+using namespace facebook;
+using namespace TinpMask;
+
+void myEventReceiver(ArkUI_NodeEvent *event);
+
+namespace rnoh {
+
+class RNTextInputMask;
+
+struct MaskParams {
+    std::string mask;                 // mask的格式
+    std::string value;                // 待mask的值
+    std::optional<bool> autocomplete; // 布尔值，表示是否自动完成
+    MaskParams() = default;
+    MaskParams(const std::string &m, const std::string &v, std::optional<bool> autoComplete = std::nullopt)
+        : mask(m), value(v), autocomplete(autoComplete) {} // 构造函数
+    MaskParams &operator=(const MaskParams &input) {
+        this->mask = input.mask;
+        this->value = input.value;
+        this->autocomplete = input.autocomplete;
+        return *this;
+    }
+};
+
+struct MaskOptions {
+    std::optional<std::vector<std::string>> affineFormats;  // 可选的字符串数组
+    std::optional<std::vector<Notation>> customNotations;   // 可选的 Notation 数组
+    std::optional<std::string> affinityCalculationStrategy; // 可选字符串
+    std::optional<bool> autocomplete;                       // 可选布尔值
+    std::optional<bool> autoskip;                           // 可选布尔值
+    std::optional<bool> rightToLeft;                        // 可选布尔值
+
+    MaskOptions()
+        : affineFormats(std::vector<std::string>()), customNotations(std::vector<Notation>()),
+          affinityCalculationStrategy(std::nullopt), autocomplete(true), autoskip(false), rightToLeft(false) {}
+    MaskOptions(const std::vector<std::string> &formats, const std::vector<Notation> &notations,
+                const std::string &strategy, bool autoComp, bool autoSkip, bool rtl)
+        : affineFormats(formats), customNotations(notations),
+          affinityCalculationStrategy(strategy.empty() ? std::make_optional("WHOLE_STRING") : std::make_optional(strategy)),
+          autocomplete(autoComp), autoskip(autoSkip), rightToLeft(rtl) {}
+};
+
+typedef struct {
+    ArkUI_NodeHandle data;
+    MaskOptions maskOptions;
+    std::string primaryFormat;
+    int node;
+    std::string lastInputText;
+    RNTextInputMask *instance;
+} UserData;
+
+class JSI_EXPORT RNTextInputMask : public ArkTSTurboModule {
+public:
+    RNTextInputMask(const ArkTSTurboModule::Context ctx, const std::string name);
+    void setMask(int reactNode, std::string primaryFormat, MaskOptions options);
+    jsi::Value mask(std::string mask, std::string value, bool autocomplete);
+    jsi::Value unmask(std::string mask, std::string value, bool autocomplete);
+    jsi::Value unmaskWithRightToLeft(std::string mask, std::string value, bool autocomplete, bool rightToLeft);
+    jsi::Runtime *grt = nullptr;
+    std::shared_ptr<Mask> pickMask(const CaretString &text, MaskOptions maskOptions, std::string primaryMask);
+
+    // 释放资源
+    ~RNTextInputMask();
+
+private:
+    std::unordered_set<UserData *> m_userDatas;
+};
+
+
+} // namespace rnoh

package/harmony/text_input_mask/src/main/cpp/RNTextInputMaskPackage.h

@@ -1,32 +1,32 @@
-/*
- * 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 "RNOH/Package.h"
-#include "RNTextInputMask.h"
-
-using namespace rnoh;
-using namespace facebook;
-namespace rnoh {
-class RNTextInputMaskTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
-public:
-    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
-        if (name == "RNTextInputMask") {
-            return std::make_shared<RNTextInputMask>(ctx, name);
-        }
-        return nullptr;
-    }
-};
-
-class RNTextInputMaskPackage : public Package {
-public:
-    RNTextInputMaskPackage(Package::Context ctx) : Package(ctx) {}
-    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override {
-        return std::make_unique<RNTextInputMaskTurboModuleFactoryDelegate>();
-    }
-    // std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;
-};
+/*
+ * 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 "RNOH/Package.h"
+#include "RNTextInputMask.h"
+
+using namespace rnoh;
+using namespace facebook;
+namespace rnoh {
+class RNTextInputMaskTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
+        if (name == "RNTextInputMask") {
+            return std::make_shared<RNTextInputMask>(ctx, name);
+        }
+        return nullptr;
+    }
+};
+
+class RNTextInputMaskPackage : public Package {
+public:
+    RNTextInputMaskPackage(Package::Context ctx) : Package(ctx) {}
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override {
+        return std::make_unique<RNTextInputMaskTurboModuleFactoryDelegate>();
+    }
+    // std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;
+};
 } // namespace rnoh

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

@@ -1,175 +1,175 @@
-/*
- * 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 <vector>
-#include <string>
-#include <memory>
-#include "model/common.h"
-#include "model/Notation.h"
-#include "model/State.h"
-#include "FormatError.h"
-#include "FormatSanitizer.h"
-#include <glog/logging.h>
-
-namespace TinpMask {
-class FormatSanitizer;
-class Compiler {
-private:
-    std::vector<Notation> customNotations;
-
-public:
-    Compiler(const std::vector<Notation> &notations) : customNotations(notations) {}
-
-    std::shared_ptr<State> compile(const std::string &formatString) {
-        FormatSanitizer sanitizer;
-        std::string sanitizedString = sanitizer.sanitize(formatString);
-        return compile(sanitizedString, false, false, '\0');
-    }
-
-    std::shared_ptr<State> compile(const std::string &formatString, bool valuable, bool fixed, char lastCharacter) {
-        if (formatString.empty()) {
-            return std::make_shared<EOLState>();
-        }
-
-        char ch = formatString.front();
-        switch (ch) {
-        case '[':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), true, false, ch);
-            }
-            break;
-
-        case '{':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), false, true, ch);
-            }
-            break;
-
-        case ']':
-        case '}':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), false, false, ch);
-            }
-            break;
-
-        case '\\':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), valuable, fixed, ch);
-            }
-            break;
-
-        default:
-            break;
-        }
-
-        if (valuable) {
-            switch (ch) {
-            case '0':
-                return std::make_shared<ValueState>(
-                    this->compile(formatString.substr(1), true, false, ch),
-                    // std::static_pointer_cast<ValueState::StateType>( std::make_shared<ValueState::Numeric>())
-                    std::make_shared<ValueState::Numeric>());
-
-            case 'A':
-                return std::make_shared<ValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                    std::make_shared<ValueState::Literal>());
-
-            case '_':
-                return std::make_shared<ValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                    std::make_shared<ValueState::AlphaNumeric>());
-
-            case '...':
-                return std::make_unique<ValueState>(determineInheritedType(lastCharacter));
-
-            case '9':
-                return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                            std::make_shared<OptionalValueState::Numeric>()
-
-                );
-
-            case 'a':
-                return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                            std::make_shared<OptionalValueState::Literal>());
-
-            case '-':
-                return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                            std::make_shared<OptionalValueState::AlphaNumeric>());
-
-            default:
-                return compileWithCustomNotations(ch, formatString);
-            }
-        }
-        if (fixed) {
-            return std::make_shared<FixedState>(compile(formatString.substr(1), false, true, ch), ch);
-        }
-        return std::make_shared<FreeState>(compile(formatString.substr(1), false, false, ch), ch);
-    }
-
-    std::unique_ptr<State> compileWithCustomNotations(char c, const std::string &str) {
-         DLOG(ERROR) << "====== compileWithCustomNotations  customNotations size: " << customNotations.size();
-        for (const auto &customNotation : customNotations) {
-            if (customNotation.character == c) {
-                std::shared_ptr<State> compiledState = compile(str.substr(1), true, false, c);
-                if (customNotation.isOptional) {
-                    DLOG(ERROR) << "====== compileWithCustomNotations  customNotations isOptional :" << customNotation.isOptional;
-                    return std::make_unique<OptionalValueState>(
-                        std::move(compiledState),
-                        std::make_shared<OptionalValueState::Custom>(c, customNotation.characterSet));
-                } else {
-                     DLOG(ERROR) << "======= compileWithCustomNotations  customNotations isOptional :" << customNotation.isOptional;
-                    return std::make_unique<ValueState>(
-                        std::move(compiledState), std::make_shared<ValueState::Custom>(c, customNotation.characterSet));
-                }
-            }
-        }
-        DLOG(INFO) << "compileWithCustomNotations No Match Found ";
-        throw FormatError("compileWithCustomNotations No Match Found");
-    }
-    std::shared_ptr<ValueState::ValueStateType> determineInheritedType(std::optional<char> lastCharacter) {
-        if (!lastCharacter.has_value()) {
-            throw FormatError(); // 处理空字符情况，抛出异常
-        }
-        char character = lastCharacter.value();
-        switch (character) {
-        case '0':
-        case '9':
-            return std::make_shared<ValueState::Numeric>();
-
-        case 'A':
-        case 'a':
-            return std::make_shared<ValueState::Literal>();
-
-        case '_':
-        case '-':
-        case '...':
-        case '[':
-            return std::make_shared<ValueState::AlphaNumeric>();
-
-        default:
-            return determineTypeWithCustomNotations(lastCharacter);
-        }
-    }
-
-    std::shared_ptr<ValueState::ValueStateType> determineTypeWithCustomNotations(std::optional<char> lastCharacter) {
-        if (!lastCharacter.has_value()) {
-            throw FormatError(); // 处理空字符情况，抛出异常
-        }
-         DLOG(INFO) << "======determineTypeWithCustomNotations customNotations size: "<<customNotations.size();
-        char character = lastCharacter.value();
-        for (const auto &customNotation : customNotations) {
-            if (customNotation.character == character) {
-                // 返回 Custom 状态
-                return std::make_shared<ValueState::Custom>(lastCharacter.value(),
-                                                            customNotation.characterSet); // 可以根据需要调整返回内容
-            }
-        }
-        DLOG(INFO) << "determineTypeWithCustomNotations No Match Found ";
-        throw FormatError("determineTypeWithCustomNotations No Match Found"); // 未找到匹配项，抛出异常
-    }
-};
+/*
+ * 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 <vector>
+#include <string>
+#include <memory>
+#include "model/common.h"
+#include "model/Notation.h"
+#include "model/State.h"
+#include "FormatError.h"
+#include "FormatSanitizer.h"
+#include <glog/logging.h>
+
+namespace TinpMask {
+class FormatSanitizer;
+class Compiler {
+private:
+    std::vector<Notation> customNotations;
+
+public:
+    Compiler(const std::vector<Notation> &notations) : customNotations(notations) {}
+
+    std::shared_ptr<State> compile(const std::string &formatString) {
+        FormatSanitizer sanitizer;
+        std::string sanitizedString = sanitizer.sanitize(formatString);
+        return compile(sanitizedString, false, false, '\0');
+    }
+
+    std::shared_ptr<State> compile(const std::string &formatString, bool valuable, bool fixed, char lastCharacter) {
+        if (formatString.empty()) {
+            return std::make_shared<EOLState>();
+        }
+
+        char ch = formatString.front();
+        switch (ch) {
+        case '[':
+            if (lastCharacter != '\\') {
+                return compile(formatString.substr(1), true, false, ch);
+            }
+            break;
+
+        case '{':
+            if (lastCharacter != '\\') {
+                return compile(formatString.substr(1), false, true, ch);
+            }
+            break;
+
+        case ']':
+        case '}':
+            if (lastCharacter != '\\') {
+                return compile(formatString.substr(1), false, false, ch);
+            }
+            break;
+
+        case '\\':
+            if (lastCharacter != '\\') {
+                return compile(formatString.substr(1), valuable, fixed, ch);
+            }
+            break;
+
+        default:
+            break;
+        }
+
+        if (valuable) {
+            switch (ch) {
+            case '0':
+                return std::make_shared<ValueState>(
+                    this->compile(formatString.substr(1), true, false, ch),
+                    // std::static_pointer_cast<ValueState::StateType>( std::make_shared<ValueState::Numeric>())
+                    std::make_shared<ValueState::Numeric>());
+
+            case 'A':
+                return std::make_shared<ValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                    std::make_shared<ValueState::Literal>());
+
+            case '_':
+                return std::make_shared<ValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                    std::make_shared<ValueState::AlphaNumeric>());
+
+            case '...':
+                return std::make_unique<ValueState>(determineInheritedType(lastCharacter));
+
+            case '9':
+                return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                            std::make_shared<OptionalValueState::Numeric>()
+
+                );
+
+            case 'a':
+                return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                            std::make_shared<OptionalValueState::Literal>());
+
+            case '-':
+                return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                            std::make_shared<OptionalValueState::AlphaNumeric>());
+
+            default:
+                return compileWithCustomNotations(ch, formatString);
+            }
+        }
+        if (fixed) {
+            return std::make_shared<FixedState>(compile(formatString.substr(1), false, true, ch), ch);
+        }
+        return std::make_shared<FreeState>(compile(formatString.substr(1), false, false, ch), ch);
+    }
+
+    std::unique_ptr<State> compileWithCustomNotations(char c, const std::string &str) {
+         DLOG(ERROR) << "====== compileWithCustomNotations  customNotations size: " << customNotations.size();
+        for (const auto &customNotation : customNotations) {
+            if (customNotation.character == c) {
+                std::shared_ptr<State> compiledState = compile(str.substr(1), true, false, c);
+                if (customNotation.isOptional) {
+                    DLOG(ERROR) << "====== compileWithCustomNotations  customNotations isOptional :" << customNotation.isOptional;
+                    return std::make_unique<OptionalValueState>(
+                        std::move(compiledState),
+                        std::make_shared<OptionalValueState::Custom>(c, customNotation.characterSet));
+                } else {
+                     DLOG(ERROR) << "======= compileWithCustomNotations  customNotations isOptional :" << customNotation.isOptional;
+                    return std::make_unique<ValueState>(
+                        std::move(compiledState), std::make_shared<ValueState::Custom>(c, customNotation.characterSet));
+                }
+            }
+        }
+        DLOG(INFO) << "compileWithCustomNotations No Match Found ";
+        throw FormatError("compileWithCustomNotations No Match Found");
+    }
+    std::shared_ptr<ValueState::ValueStateType> determineInheritedType(std::optional<char> lastCharacter) {
+        if (!lastCharacter.has_value()) {
+            throw FormatError(); // 处理空字符情况，抛出异常
+        }
+        char character = lastCharacter.value();
+        switch (character) {
+        case '0':
+        case '9':
+            return std::make_shared<ValueState::Numeric>();
+
+        case 'A':
+        case 'a':
+            return std::make_shared<ValueState::Literal>();
+
+        case '_':
+        case '-':
+        case '...':
+        case '[':
+            return std::make_shared<ValueState::AlphaNumeric>();
+
+        default:
+            return determineTypeWithCustomNotations(lastCharacter);
+        }
+    }
+
+    std::shared_ptr<ValueState::ValueStateType> determineTypeWithCustomNotations(std::optional<char> lastCharacter) {
+        if (!lastCharacter.has_value()) {
+            throw FormatError(); // 处理空字符情况，抛出异常
+        }
+         DLOG(INFO) << "======determineTypeWithCustomNotations customNotations size: "<<customNotations.size();
+        char character = lastCharacter.value();
+        for (const auto &customNotation : customNotations) {
+            if (customNotation.character == character) {
+                // 返回 Custom 状态
+                return std::make_shared<ValueState::Custom>(lastCharacter.value(),
+                                                            customNotation.characterSet); // 可以根据需要调整返回内容
+            }
+        }
+        DLOG(INFO) << "determineTypeWithCustomNotations No Match Found ";
+        throw FormatError("determineTypeWithCustomNotations No Match Found"); // 未找到匹配项，抛出异常
+    }
+};
 } // namespace TinpMask

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

@@ -1,23 +1,23 @@
-/*
- * 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
-// 定义 FormatError 类
-#include <string>
-
-namespace TinpMask {
-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(); }
-
-private:
-    std::string msg; // 存储错误消息
-};
+/*
+ * 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
+// 定义 FormatError 类
+#include <string>
+
+namespace TinpMask {
+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(); }
+
+private:
+    std::string msg; // 存储错误消息
+};
 } // namespace TinpMask