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

package/harmony/text_input_mask/src/main/cpp/common/model/Notation.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 <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

package/harmony/text_input_mask/src/main/cpp/common/model/RTLCaretStringIterator.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
+#include "CaretString.h"
+#include "CaretStringIterator.h"
+
+namespace TinpMask {
+
+class RTLCaretStringIterator : public CaretStringIterator {
+public:
+    RTLCaretStringIterator(const CaretString& caretString)
+        : CaretStringIterator(caretString) {}
+
+    bool insertionAffectsCaret()  {
+        return currentIndex <= caretString.caretPosition;
+    }
+};
+
+}

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

@@ -0,0 +1,302 @@
+/*
+ * 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 <iostream>
+
+namespace TinpMask {
+
+
+class Next;
+class State {
+public:
+    std::shared_ptr<State> child; // 指向下一个状态的智能指针
+
+public:
+    // 构造函数
+    explicit State(std::shared_ptr<State> child = nullptr) : child(child) {}
+
+    // 虚析构函数，以确保派生类的析构函数被正确调用
+    virtual ~State() = default;
+
+    /**
+     * Abstract method.
+     *
+     * Defines whether the state accepts user input character or not, and which actions should take
+     * place when the character is accepted.
+     *
+     * @param character character from the user input string.
+     *
+     * @returns Next object instance with a set of actions that should take place when the user
+     * input character is accepted.
+     *
+     * @throws Fatal error, if the method is not implemented.
+     */
+    virtual std::shared_ptr<Next> accept(char character) = 0;
+
+    /**
+     * Automatically complete user input.
+     *
+     * @returns Next object instance with a set of actions to complete user input. If no
+     * autocomplete available, returns nullptr.
+     */
+    virtual std::shared_ptr<Next> autocomplete() {
+        return nullptr; // 默认返回 nullptr
+    }
+
+    /**
+     * Obtain the next state.
+     *
+     * Sometimes it is necessary to override this behavior. For instance, State may want to
+     * return self as the next state under certain conditions.
+     *
+     * @returns State object.
+     */
+    virtual std::shared_ptr<State> nextState() {
+        return child; // 返回下一个状态
+    }
+
+    // 转换为字符串表示
+    virtual std::string toString() const { return "BASE -> " + (child ? child->toString() : "null"); }
+};
+
+// EOLState 类的实现
+class EOLState : public State {
+public:
+    EOLState(std::shared_ptr<State> child = nullptr) : State(child) {}
+
+    std::shared_ptr<Next> accept(char character) override {
+        return nullptr; // 该状态不接受字符
+    }
+
+    std::string toString() const override {
+        return "EOL"; // 返回字符串表示
+    }
+};
+
+
+// FixedState 类的实现
+class FixedState : public State {
+public:
+    char ownCharacter;
+
+public:
+    FixedState(std::shared_ptr<State> child, char ownCharacter) : State(child), ownCharacter(ownCharacter) {}
+
+    std::shared_ptr<Next> accept(char character) override {
+        if (this->ownCharacter == character) {
+            return std::make_shared<Next>(this->nextState(), character, true, character);
+        } else {
+            return std::make_shared<Next>(this->nextState(), this->ownCharacter, false, this->ownCharacter);
+        }
+    }
+
+    std::shared_ptr<Next> autocomplete() override {
+        return std::make_shared<Next>(this->nextState(), this->ownCharacter, false, this->ownCharacter);
+    }
+
+    std::string toString() const override {
+        return "{" + std::string(1, this->ownCharacter) + "} -> " + (child ? child->toString() : "null");
+    }
+};
+
+// FreeState 类的实现
+class FreeState : public State {
+public:
+    char ownCharacter;
+
+public:
+    FreeState(std::shared_ptr<State> child, char ownCharacter) : State(child), ownCharacter(ownCharacter) {}
+
+    std::shared_ptr<Next> accept(char character) override {
+        if (this->ownCharacter == character) {
+            return std::make_shared<Next>(this->nextState(), character, true, '\0');
+        } else {
+            return std::make_shared<Next>(this->nextState(), this->ownCharacter, false, '\0');
+        }
+    }
+
+    std::shared_ptr<Next> autocomplete() override {
+        return std::make_shared<Next>(this->nextState(), this->ownCharacter, false, '\0');
+    }
+
+    std::string toString() const override {
+        return std::string(1, this->ownCharacter) + " -> " + (child ? child->toString() : "null");
+    }
+};
+enum StateTypeName { Numeric, Literal, AlphaNumeric, Custom };
+class OptionalValueState : public State {
+public:
+    class OptionalValueStateType {
+    public:
+        virtual StateTypeName getName() = 0;
+    };
+
+    class Numeric : public OptionalValueStateType {
+    public:
+        StateTypeName getName() override { return StateTypeName::Numeric; }
+    };
+    class Literal : public OptionalValueStateType {
+    public:
+        StateTypeName getName() override { return StateTypeName::Literal; }
+    };
+    class AlphaNumeric : public OptionalValueStateType {
+    public:
+        StateTypeName getName() override { return StateTypeName::AlphaNumeric; }
+    };
+
+    class Custom : public OptionalValueStateType {
+    public:
+        char character;
+        std::string characterSet;
+        StateTypeName getName() override { return StateTypeName::Custom; }
+        Custom(char character, const std::string &characterSet) : character(character), characterSet(characterSet) {}
+    };
+
+public:
+    std::shared_ptr<OptionalValueStateType> type;
+
+    bool accepts(char character) {
+        if (dynamic_cast<Numeric *>(type.get())) {
+            return std::isdigit(character);
+        } else if (dynamic_cast<Literal *>(type.get())) {
+            return std::isalpha(character);
+        } else if (dynamic_cast<AlphaNumeric *>(type.get())) {
+            return std::isalnum(character);
+        } else if (auto customType = dynamic_cast<Custom *>(type.get())) {
+            return customType->characterSet.find(character) != std::string::npos;
+        }
+        return false;
+    }
+
+    OptionalValueState(std::shared_ptr<State> child, std::shared_ptr<OptionalValueStateType> type)
+        : State(child), type(type) {}
+
+    OptionalValueState(std::shared_ptr<State> child, std::shared_ptr<OptionalValueStateType> &type)
+        : State(child), type(type) {}
+
+    std::shared_ptr<Next> accept(char character) override {
+        if (this->accepts(character)) {
+            return std::make_shared<Next>(this->nextState(), character, true, character);
+        } else {
+            return std::make_shared<Next>(this->nextState(), '\0', false, '\0');
+        }
+    }
+
+    std::string toString() const override {
+        if (dynamic_cast<Literal *>(type.get())) {
+            return "[a] -> " + (child ? child->toString() : "null");
+        } else if (dynamic_cast<Numeric *>(type.get())) {
+            return "[9] -> " + (child ? child->toString() : "null");
+        } else if (dynamic_cast<AlphaNumeric *>(type.get())) {
+            return "[-] -> " + (child ? child->toString() : "null");
+        } else if (auto customType = dynamic_cast<Custom *>(type.get())) {
+            return "[" + std::string(1, customType->character) + "] -> " + (child ? child->toString() : "null");
+        }
+        return "unknown -> null";
+    }
+};
+
+// ValueState 类定义
+class ValueState : public State, public std::enable_shared_from_this<ValueState> {
+public:
+    class ValueStateType {
+    public:
+        virtual StateTypeName getName() = 0;
+    };
+
+    class Numeric : public ValueStateType {
+    public:
+        StateTypeName getName() override { return StateTypeName::Numeric; }
+    };
+    class Literal : public ValueStateType {
+    public:
+        StateTypeName getName() override { return StateTypeName::Literal; }
+    };
+    class AlphaNumeric : public ValueStateType {
+    public:
+        StateTypeName getName() override { return StateTypeName::AlphaNumeric; }
+    };
+    class Ellipsis : public ValueStateType {
+    public:
+        std::shared_ptr<ValueStateType> inheritedType;
+        explicit Ellipsis(std::shared_ptr<ValueStateType> inheritedType) : inheritedType(inheritedType) {}
+        StateTypeName getName() override { return StateTypeName::Custom; }
+    };
+    class Custom : public ValueStateType {
+
+    public:
+        char character;
+        std::string characterSet;
+        Custom(char character, const std::string &characterSet) : character(character), characterSet(characterSet) {}
+        StateTypeName getName() override { return StateTypeName::Custom; }
+    };
+
+public:
+    std::shared_ptr<ValueStateType> type;
+    bool accepts(char character) {
+        if (dynamic_cast<Numeric *>(type.get())) {
+            return std::isdigit(character);
+        } else if (dynamic_cast<Literal *>(type.get())) {
+            return std::isalpha(character);
+        } else if (dynamic_cast<AlphaNumeric *>(type.get())) {
+            return std::isalnum(character);
+        } else if (auto ellipsisType = dynamic_cast<Ellipsis *>(type.get())) {
+            return acceptsWithInheritedType(ellipsisType->inheritedType, character);
+        } else if (auto customType = dynamic_cast<Custom *>(type.get())) {
+            return customType->characterSet.find(character) != std::string::npos;
+        }
+        return false;
+    }
+
+    bool acceptsWithInheritedType(std::shared_ptr<ValueStateType> inheritedType, char character) {
+        if (dynamic_cast<Numeric *>(inheritedType.get())) {
+            return std::isdigit(character);
+        } else if (dynamic_cast<Literal *>(inheritedType.get())) {
+            return std::isalpha(character);
+        } else if (dynamic_cast<AlphaNumeric *>(inheritedType.get())) {
+            return std::isalnum(character);
+        } else if (auto customType = dynamic_cast<Custom *>(inheritedType.get())) {
+            return customType->characterSet.find(character) != std::string::npos;
+        }
+        return false;
+    }
+
+public:
+    // 构造函数用于创建 Ellipsis 类型的 ValueState
+    ValueState(std::shared_ptr<ValueStateType> inheritedType)
+        : State(nullptr), type(std::make_shared<Ellipsis>(inheritedType)) {}
+
+    ValueState(std::shared_ptr<State> child, std::shared_ptr<ValueStateType> type) : State(child), type(type) {}
+
+    std::shared_ptr<Next> accept(char character) override {
+        if (!accepts(character))
+            return nullptr;
+        return std::make_shared<Next>(nextState(), character, true, character);
+    }
+
+    bool isElliptical() const { return dynamic_cast<Ellipsis *>(type.get()) != nullptr; }
+
+    std::shared_ptr<State> nextState() override { return isElliptical() ? shared_from_this() : State::nextState(); }
+
+    std::string toString() const override {
+        if (dynamic_cast<Literal *>(type.get())) {
+            return "[A] -> " + (child ? child->toString() : "null");
+        } else if (dynamic_cast<Numeric *>(type.get())) {
+            return "[0] -> " + (child ? child->toString() : "null");
+        } else if (dynamic_cast<AlphaNumeric *>(type.get())) {
+            return "[_] -> " + (child ? child->toString() : "null");
+        } else if (dynamic_cast<Ellipsis *>(type.get())) {
+            return "[…] -> " + (child ? child->toString() : "null");
+        } else if (auto customType = dynamic_cast<Custom *>(type.get())) {
+            return "[" + std::string(1, customType->character) + "] -> " + (child ? child->toString() : "null");
+        }
+        return "unknown -> null";
+    }
+};
+
+}

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

@@ -0,0 +1,95 @@
+/*
+ * 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 "CaretString.h"
+#include <string>
+#include <vector>
+#include "State.h"
+#include "Next.h"
+
+namespace TinpMask {
+
+class Result {
+public:
+    // 属性
+    CaretString formattedText;
+    std::string extractedValue;
+    int affinity;
+    bool complete;
+    std::string tailPlaceholder;
+
+    // 构造函数
+    Result(const CaretString &formattedText, const std::string &extractedValue, int affinity, bool complete,
+           const std::string &tailPlaceholder)
+        : formattedText(formattedText), extractedValue(extractedValue), affinity(affinity), complete(complete),
+          tailPlaceholder(tailPlaceholder) {}
+
+    // reversed 方法
+    Result reversed() const {
+        return Result(this->formattedText.reversed(), reverseString(this->extractedValue), this->affinity,
+                      this->complete, reverseString(this->tailPlaceholder));
+    }
+
+private:
+    // 辅助函数，用于反转字符串
+    std::string reverseString(const std::string &str) const { return std::string(str.rbegin(), str.rend()); }
+};
+/**
+ * While scanning through the input string in the `.apply(…)` method, the mask builds a graph of
+ * autocompletion steps.
+ *
+ * This graph accumulates the results of `.autocomplete()` calls for each consecutive ``State``,
+ * acting as a `stack` of ``Next`` object instances.
+ *
+ * Each time the ``State`` returns `null` for its `.autocomplete()`, the graph resets empty.
+ */
+class AutocompletionStack {
+private:
+    std::vector<Next> stack;
+
+public:
+    // Push 方法
+    std::optional<Next> push(const std::optional<Next> &item) {
+        if (item.has_value()) {
+            stack.push_back(item.value());
+            return item;
+        } else {
+            clear();             // 清空栈
+            return std::nullopt; // 返回 std::nullopt
+        }
+    }
+
+    // 清空栈的方法
+    void clear() { stack.clear(); }
+
+    // Optional: 获取栈的元素（用于检查或调试）
+    std::vector<Next> getStack() const {
+        return stack; // 返回当前栈的拷贝
+    }
+
+    // Optional: 从栈中弹出一个元素
+    std::optional<Next> pop() {
+        if (stack.empty()) {
+            return std::nullopt; // 栈为空时返回 std::nullopt
+        }
+        Next item = stack.back();
+        stack.pop_back();
+        return item;
+    }
+
+    // 检查栈是否为空
+    bool isEmpty() const { return stack.empty(); }
+
+    // Optional: 获取栈顶元素而不移除它
+    std::optional<Next> peek() const {
+        if (stack.empty()) {
+            return std::nullopt; // 栈为空时返回 std::nullopt
+        }
+        return stack.back();
+    }
+};
+} // namespace TinpMask

package/harmony/text_input_mask/src/main/ets/RNTextInputMaskPackage.ts

@@ -0,0 +1,29 @@
+/*
+ * 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.
+ */
+
+import { RNPackage, TurboModulesFactory } from '@rnoh/react-native-openharmony/ts';
+import type { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { RNTextInputMaskTurboModule } from './RNTextInputMaskTurboModle';
+
+class RNTextInputMaskTurboModuleFactory extends TurboModulesFactory {
+  createTurboModule(name: string): TurboModule | null {
+    globalThis.uiAbilityContext = this.ctx.uiAbilityContext
+    if (this.hasTurboModule(name)) {
+      return new RNTextInputMaskTurboModule(this.ctx);
+    }
+    return null;
+  }
+
+  hasTurboModule(name: string): boolean {
+    return name === "RNTextInputMask";
+  }
+}
+
+export class RNTextInputMaskPackage extends RNPackage {
+  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
+    return new RNTextInputMaskTurboModuleFactory(ctx);
+  }
+}

package/harmony/text_input_mask/src/main/ets/RNTextInputMaskTurboModle.ts

@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+import { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+
+export class RNTextInputMaskTurboModule extends TurboModule  {
+  private context: TurboModuleContext;
+
+  constructor(ctx: TurboModuleContext) {
+    super(ctx)
+    this.context = ctx
+  }
+
+  mask(mask: string, value: string, autocomplete: boolean): Promise<string> {
+    return;
+  }
+
+  unmask(mask: string, value: string, autocomplete: boolean): Promise<string> {
+    return;
+  }
+
+  setMask(reactNode: number, primaryFormat: string, options: object): void {
+    console.log("==================", "setMask")
+  }
+
+  unmaskWithRightToLeft(mask: string, value: string, autocomplete: boolean, rightToLeft: boolean): Promise<string> {
+    return;
+  }
+
+}

package/harmony/text_input_mask/src/main/module.json5

@@ -0,0 +1,11 @@
+{
+  "module": {
+    "name": "text_input_mask",
+    "type": "har",
+    "deviceTypes": [
+      "default",
+      "tablet",
+      "2in1"
+    ]
+  }
+}

package/harmony/text_input_mask/src/main/resources/base/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from package"
+    }
+  ]
+}

package/harmony/text_input_mask/src/main/resources/en_US/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from package"
+    }
+  ]
+}

package/harmony/text_input_mask/src/main/resources/zh_CN/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from package"
+    }
+  ]
+}

package/harmony/text_input_mask/ts.ts

@@ -0,0 +1,8 @@
+/*
+* 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.
+*/
+
+export * from './src/main/ets/RNTextInputMaskPackage';
+export * from "./src/main/ets/RNTextInputMaskTurboModle"