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

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

@@ -0,0 +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"); // 未找到匹配项，抛出异常
+    }
+};
+} // namespace TinpMask

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

@@ -0,0 +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; // 存储错误消息
+};
+} // namespace TinpMask

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

@@ -0,0 +1,231 @@
+/*
+ * 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 <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include "Compiler.h"
+
+namespace TinpMask {
+
+
+class Compiler;
+class FormatSanitizer {
+public:
+    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> blocks;
+        std::string currentBlock;
+        bool escape = false;
+
+        for (char ch : formatString) {
+            if (ch == '\\') {
+                if (!escape) {
+                    escape = true;
+                    currentBlock += ch;
+                    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> resultingBlocks;
+
+        for (const auto &block : blocks) {
+            if (!block.empty() && block.substr(0, 1) == "[") { // 使用 substr 来检查开头
+                std::string blockBuffer;
+                for (char blockCharacter : block) {
+                    if (blockCharacter == '[') {
+                        blockBuffer += blockCharacter;
+                        continue;
+                    }
+
+                    if (blockCharacter == ']' && !endsWithEscapeCharacter(blockBuffer)) {
+                        blockBuffer += blockCharacter;
+                        resultingBlocks.push_back(blockBuffer);
+                        break;
+                    }
+
+                    if (isDigit(blockCharacter)) {
+                        if (containsAny(blockBuffer, {'A', 'a', '-', '_'})) {
+                            blockBuffer += "]";
+                            resultingBlocks.push_back(blockBuffer);
+                            blockBuffer = "[" + std::string(1, blockCharacter);
+                            continue;
+                        }
+                    }
+
+                    if (isAlpha(blockCharacter)) {
+                        if (containsAny(blockBuffer, {'0', '9', '-', '_'})) {
+                            blockBuffer += "]";
+                            resultingBlocks.push_back(blockBuffer);
+                            blockBuffer = "[" + std::string(1, blockCharacter);
+                            continue;
+                        }
+                    }
+
+                    if (isSpecialCharacter(blockCharacter)) {
+                        if (containsAny(blockBuffer, {'0', '9', 'A', 'a'})) {
+                            blockBuffer += "]";
+                            resultingBlocks.push_back(blockBuffer);
+                            blockBuffer = "[" + std::string(1, blockCharacter);
+                            continue;
+                        }
+                    }
+
+                    blockBuffer += blockCharacter;
+                }
+            } else {
+                resultingBlocks.push_back(block);
+            }
+        }
+
+        return resultingBlocks;
+    }
+
+private:
+    bool endsWithEscapeCharacter(const std::string &str) const { return !str.empty() && str.back() == '\\'; }
+
+    bool isDigit(char ch) const { return ch >= '0' && ch <= '9'; }
+
+    bool isAlpha(char ch) const { return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'); }
+
+    bool isSpecialCharacter(char ch) const { return ch == '-' || ch == '_'; }
+
+    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;
+            }
+        }
+        return false;
+    }
+
+public:
+    std::string sortFormatBlocks(const std::vector<std::string> &blocks) {
+        std::vector<std::string> sortedBlocks;
+
+        for (const auto &block : blocks) {
+            std::string sortedBlock;
+
+            if (startsWith(block, "[")) {
+                std::string cleanedBlock = block.substr(1, block.size() - 2); // Remove the surrounding brackets
+                if (cleanedBlock.find("0") != std::string::npos || cleanedBlock.find("9") != std::string::npos ||
+                    cleanedBlock.find("a") != std::string::npos || cleanedBlock.find("A") != std::string::npos) {
+                    sortedBlock = "[" + sortString(cleanedBlock) + "]";
+                } else {
+                    cleanedBlock = replaceChars(cleanedBlock);
+                    sortedBlock = "[" + sortString(cleanedBlock) + "]";
+                    sortedBlock = replaceCharsBack(sortedBlock);
+                }
+            } else {
+                sortedBlock = block;
+            }
+
+            sortedBlocks.push_back(sortedBlock);
+        }
+
+        return join(sortedBlocks); // Ensure this is returning std::vector<std::string>
+    }
+
+    void checkOpenBraces(const std::string &inputString) {
+        bool escape = false;
+        bool squareBraceOpen = false;
+        bool curlyBraceOpen = false;
+
+        for (const char &ch : inputString) {
+            if (ch == '\\') {
+                escape = !escape;
+                continue;
+            }
+
+            if (ch == '[') {
+                if (squareBraceOpen) {
+                    throw FormatError();
+                }
+                squareBraceOpen = !escape;
+            }
+
+            if (ch == ']' && !escape) {
+                squareBraceOpen = false;
+            }
+
+            if (ch == '{') {
+                if (curlyBraceOpen) {
+                    throw FormatError();
+                }
+                curlyBraceOpen = !escape;
+            }
+
+            if (ch == '}' && !escape) {
+                curlyBraceOpen = false;
+            }
+            escape = false;
+        }
+    }
+
+private:
+    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 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 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 result;
+        for (const auto &str : strings) {
+            result += str; // 将所有块连接成一个字符串
+        }
+        return result;
+    }
+};
+} // namespace TinpMask