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

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

@@ -0,0 +1,378 @@
+/*
+ * 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 <map>
+#include <memory>
+#include "model/CaretStringIterator.h"
+#include "model/common.h" // 假设这些头文件定义了相关类
+#include "Compiler.h"
+#include "model/State.h"
+
+namespace TinpMask {
+
+class Mask {
+protected:
+    std::vector<Notation> customNotations;
+
+private:
+    std::shared_ptr<State> initialState;
+
+private:
+    std::string format;
+
+public:
+    // 主构造函数
+    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
+        std::vector<Notation> emptyVector;
+        this->format = format;
+        this->customNotations = emptyVector;
+        this->initialState = Compiler(this->customNotations).compile(this->format);
+    }
+
+
+    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
+         * corresponding format key: `[format : mask]`
+         *
+         * @returns Previously cached ``Mask`` object for requested format string. If such it
+         * 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) {
+            auto cachedMask = maskCache.find(format);
+            if (cachedMask == maskCache.end()) {
+                auto newMask = std::make_shared<Mask>(format, customNotations);
+                maskCache[format] = newMask;
+                return newMask;
+            }
+            return cachedMask->second;
+        }
+
+        /**
+         * Check your mask format is valid.
+         *
+         * @param format mask format.
+         * @param customNotations a list of custom rules to compile square bracket `[]` groups of format symbols.
+         *
+         * @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) {
+            try {
+                Mask(format, customNotations);
+                return true;
+            } catch (const FormatError &) {
+                return false;
+            }
+        }
+    };
+    /**
+     * 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) {
+        auto iterator = makeIterator(text); // Assume this function is defined
+
+        int affinity = 0;
+        std::string extractedValue;
+        std::string modifiedString;
+        int modifiedCaretPosition = text.caretPosition;
+
+        std::shared_ptr<State> state = initialState;
+        AutocompletionStack autocompletionStack;
+
+        bool insertionAffectsCaret = iterator->insertionAffectsCaret();
+        bool deletionAffectsCaret = iterator->deletionAffectsCaret();
+        char character = iterator->next();
+        while (character != '\0') {
+            auto next = state->accept(character);
+
+            if (next != nullptr) {
+                if (deletionAffectsCaret) {
+                    auto opt = state->autocomplete();
+                    if (opt != nullptr) {
+                        autocompletionStack.push(*opt);
+                    }
+                }
+                state = next->state;
+                if (next->insert == '\0') {
+                    modifiedString += "";
+                } else {
+                    modifiedString += next->insert;
+                }
+                if (next->value == '\0') {
+                    extractedValue += "";
+                } else {
+                    extractedValue += next->value;
+                }
+                if (next->pass) {
+                    insertionAffectsCaret = iterator->insertionAffectsCaret();
+                    deletionAffectsCaret = iterator->deletionAffectsCaret();
+                    character = iterator->next();
+                    affinity += 1;
+                } else {
+                    if (insertionAffectsCaret && next->insert != '\0') {
+                        modifiedCaretPosition += 1;
+                    }
+                    affinity -= 1;
+                }
+            } else {
+                if (deletionAffectsCaret) {
+                    modifiedCaretPosition -= 1;
+                }
+                insertionAffectsCaret = iterator->insertionAffectsCaret();
+                deletionAffectsCaret = iterator->deletionAffectsCaret();
+                character = iterator->next();
+                affinity -= 1;
+            }
+        }
+
+        while (text.caretGravity->autocomplete() && insertionAffectsCaret) {
+            auto next = state->autocomplete();
+            if (next == nullptr)
+                break;
+
+            state = next->state;
+            if (next->insert == '\0') {
+                modifiedString += "";
+            } else {
+                modifiedString += next->insert;
+            }
+            if (next->value == '\0') {
+                extractedValue += "";
+            } else {
+                extractedValue += next->value;
+            }
+            if (next->insert == '\0') {
+                modifiedCaretPosition += 1;
+            }
+        }
+        std::shared_ptr<State> tailState = state;
+        std::string tail;
+        while (text.caretGravity->autoskip() && !autocompletionStack.isEmpty()) {
+            auto skip = autocompletionStack.pop();
+            if (modifiedString.length() == modifiedCaretPosition) {
+                if (!skip->insert == '\0' && skip->insert == modifiedString.back()) {
+                    modifiedString.pop_back();
+                    modifiedCaretPosition -= 1;
+                }
+                if (skip.has_value() && skip.value().value == modifiedString.back()) {
+                    extractedValue.pop_back();
+                }
+            } else {
+                if (!skip->insert == '\0') {
+                    modifiedCaretPosition -= 1;
+                }
+            }
+            tailState = skip->state;
+            tail += skip->insert;
+        }
+
+        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);
+    }
+
+
+public:
+    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(), ""); }
+    /**
+     * 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() {
+        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 ||
+                dynamic_cast<ValueState *>(state.get()) != nullptr) {
+                length += 1;
+            }
+            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 {
+        std::shared_ptr<State> state = 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 ||
+                dynamic_cast<ValueState *>(state.get()) != nullptr ||
+                dynamic_cast<OptionalValueState *>(state.get()) != nullptr) {
+                length += 1;
+            }
+            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 {
+        std::shared_ptr<State> state = initialState;
+        int length = 0;
+        while (state != nullptr && dynamic_cast<EOLState *>(state.get()) == nullptr) {
+            if (dynamic_cast<FixedState *>(state.get()) != nullptr ||
+                dynamic_cast<ValueState *>(state.get()) != nullptr) {
+                length += 1;
+            }
+            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 {
+        std::shared_ptr<State> state = initialState;
+        int length = 0;
+        while (state != nullptr && dynamic_cast<EOLState *>(state.get()) == nullptr) {
+            if (dynamic_cast<FixedState *>(state.get()) != nullptr ||
+                dynamic_cast<ValueState *>(state.get()) != nullptr ||
+                dynamic_cast<OptionalValueState *>(state.get()) != nullptr) {
+                length += 1;
+            }
+            state = state->child; // 移动到下一个子状态
+        }
+        return length;
+    }
+
+private:
+    std::string appendPlaceholder(State *state, const std::string &placeholder) const {
+        if (state == nullptr) {
+            return placeholder;
+        }
+
+        if (dynamic_cast<EOLState *>(state)) {
+            return placeholder;
+        }
+
+        if (auto fixedState = dynamic_cast<FixedState *>(state)) {
+            return appendPlaceholder(fixedState->child.get(), placeholder + fixedState->ownCharacter);
+        }
+
+        if (auto freeState = dynamic_cast<FreeState *>(state)) {
+            return appendPlaceholder(freeState->child.get(), placeholder + freeState->ownCharacter);
+        }
+
+        if (auto optionalValueState = dynamic_cast<OptionalValueState *>(state)) {
+            if (!state) {
+                return placeholder; // 如果 state 为 nullptr，直接返回原始 placeholder
+            }
+            // 使用 if-else 替代 switch
+            if (optionalValueState->type->getName() == StateTypeName::Numeric) {
+                return appendPlaceholder(state->child.get(), placeholder + "0");
+            } else if (optionalValueState->type->getName() == StateTypeName::Literal) {
+                return appendPlaceholder(state->child.get(), placeholder + "a");
+            } else if (optionalValueState->type->getName() == StateTypeName::AlphaNumeric) {
+                return appendPlaceholder(state->child.get(), placeholder + "-");
+            } else if (optionalValueState->type->getName() == StateTypeName::Custom) {
+                auto customValueState = dynamic_cast<OptionalValueState *>(state);
+                auto customStateType = dynamic_cast<OptionalValueState::Custom *>(customValueState->type.get());
+                return appendPlaceholder(state->child.get(), placeholder + customStateType->character);
+            } else {
+                return placeholder; // 未知类型，返回原始 placeholder
+            }
+        }
+
+        if (auto valueState = dynamic_cast<ValueState *>(state)) {
+            if (!state) {
+                return placeholder; // 如果 state 为 nullptr，直接返回原始 placeholder
+            }
+            // 使用 if-else 替代 switch
+            if (valueState->type->getName() == StateTypeName::Numeric) {
+                return appendPlaceholder(state->child.get(), placeholder + "0");
+            } else if (valueState->type->getName() == StateTypeName::Literal) {
+                return appendPlaceholder(state->child.get(), placeholder + "a");
+            } else if (valueState->type->getName() == StateTypeName::AlphaNumeric) {
+                return appendPlaceholder(state->child.get(), placeholder + "-");
+            } else if (valueState->type->getName() == StateTypeName::Custom) {
+                auto customValueState = dynamic_cast<ValueState *>(state);
+                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 {
+                return placeholder; // 未知类型，返回原始 placeholder
+            }
+        }
+
+        return placeholder;
+    }
+
+    bool noMandatoryCharactersLeftAfterState(State *state) const {
+        if (dynamic_cast<EOLState *>(state)) {
+            return true;
+        } else if (auto valueState = dynamic_cast<ValueState *>(state)) {
+            return valueState->isElliptical();
+        } else if (dynamic_cast<FixedState *>(state)) {
+            return false;
+        } else {
+            return noMandatoryCharactersLeftAfterState(state->nextState().get());
+        }
+    }
+};
+} // namespace TinpMask

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

@@ -0,0 +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;
+    }
+};
+}

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

@@ -0,0 +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);
+    }
+};
+} // namespace TinpMask

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

@@ -0,0 +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; // 光标重力
+};
+
+} // namespace TinpMask

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

@@ -0,0 +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

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

@@ -0,0 +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) {}
+};
+} // namespace TinpMask