@react-native-ohos/react-native-text-input-mask 3.1.6-rc.4 → 3.1.6-rc.5

package/harmony/text_input_mask/src/main/cpp/RNTextInputMask.cpp

@@ -22,9 +22,12 @@ using namespace rnoh;
 using namespace react;
 using namespace TinpMask;
 static constexpr int AVOIDENCE = 1;
+static constexpr int EVENT_ID_ONCHANGE = 110;
+static constexpr int EVENT_ID_ONFOCUS = 111;
 std::unordered_map<std::string, std::shared_ptr<RTLMask>> TinpMask::RTLMask::cache;
 std::unordered_map<std::string, std::shared_ptr<Mask>> TinpMask::Mask::MaskFactory::maskCache;
-void maybeThrow(int32_t status) {
+void maybeThrow(int32_t status)
+{
     DLOG(INFO) << "=====text change maybeThrow status: " << status;
     if (status != 0) {
         auto message = std::string("ArkUINode operation failed with status: ") + std::to_string(status);
@@ -33,7 +36,8 @@ void maybeThrow(int32_t status) {
     }
 }
 
-void myEventReceiver(ArkUI_NodeEvent *event) {
+void myEventReceiver(ArkUI_NodeEvent *event)
+{
     int32_t eventId = OH_ArkUI_NodeEvent_GetTargetId(event);
     ArkUI_NodeHandle textNode = OH_ArkUI_NodeEvent_GetNodeHandle(event);
     void *data = NativeNodeApi::getInstance()->getUserData(textNode);
@@ -41,11 +45,12 @@ void myEventReceiver(ArkUI_NodeEvent *event) {
     std::string content = item->string;
     UserData *userData = reinterpret_cast<UserData *>(data);
     auto self = userData->instance;
-    if (self == nullptr) { return; };
+    if (self == nullptr) {
+        return;
+    };
     bool isDelete = userData->lastInputText.size() >= content.size();
     bool useAutocomplete = !isDelete ? userData->maskOptions.autocomplete.value() : false;
     bool useAutoskip = isDelete ? userData->maskOptions.autoskip.value() : false;
-
     // onChange 事件
     if (eventId == userData->node) {
         std::shared_ptr<CaretString::CaretGravity> caretGravity = nullptr;
@@ -65,26 +70,30 @@ void myEventReceiver(ArkUI_NodeEvent *event) {
                 content = resultString;
             }
             std::string finalString = isDelete ? content : resultString;
-            ArkUI_AttributeItem item{.string = finalString.c_str()};
+            ArkUI_AttributeItem item{
+                .string = finalString.c_str()
+            };
             userData->lastInputText = finalString;
             maybeThrow(NativeNodeApi::getInstance()->setAttribute(userData->data, NODE_TEXT_INPUT_TEXT, &item));
-        } catch (FormatError e) {
+        } catch (const FormatError &e) {
             DLOG(ERROR) << " mask complier error " << e.what();
         }
     }
     // onFocus 事件
-    if (eventId == 111) {
+    if (eventId == EVENT_ID_ONFOCUS) {
         if (userData->maskOptions.autocomplete.value()) {
             std::string text = "";
             text += content;
             try {
                 CaretString string(text, text.length(),
-                                   std::make_shared<CaretString::Forward>(userData->maskOptions.autocomplete.value()));
+                    std::make_shared<CaretString::Forward>(userData->maskOptions.autocomplete.value()));
                 auto maskObj = self->pickMask(string, userData->maskOptions, userData->primaryFormat);
                 std::string resultString = maskObj->apply(string).formattedText.string;
-                ArkUI_AttributeItem item{.string = resultString.c_str()};
+                ArkUI_AttributeItem item{
+                    .string = resultString.c_str()
+                };
                 maybeThrow(NativeNodeApi::getInstance()->setAttribute(userData->data, NODE_TEXT_INPUT_TEXT, &item));
-            } catch (FormatError e) {
+            } catch (const FormatError &e) {
                 DLOG(ERROR) << " mask complier error " << e.what();
             }
         }
@@ -92,7 +101,8 @@ void myEventReceiver(ArkUI_NodeEvent *event) {
 }
 
 // 计算亲和度
-int calculateAffinity(Mask mask, const CaretString &text, std::string affinityCalculationStrategy) {
+int calculateAffinity(Mask mask, const CaretString &text, std::string affinityCalculationStrategy)
+{
     AffinityCalculationStrategy strategy;
     if (affinityCalculationStrategy == "WHOLE_STRING") {
         strategy = AffinityCalculationStrategy::WHOLE_STRING;
@@ -109,7 +119,8 @@ int calculateAffinity(Mask mask, const CaretString &text, std::string affinityCa
 }
 // 获取或创建 Mask
 std::shared_ptr<Mask> maskGetOrCreate(const std::string &format, const std::vector<Notation> &customNotations,
-                                      bool rightToLeft) {
+    bool rightToLeft)
+{
     if (rightToLeft) {
         return RTLMask::getOrCreate(format, customNotations);
     } else {
@@ -118,13 +129,14 @@ std::shared_ptr<Mask> maskGetOrCreate(const std::string &format, const std::vect
 }
 
 std::shared_ptr<Mask> RNTextInputMask::pickMask(const CaretString &text, MaskOptions maskOptions,
-                                                std::string primaryMask) {
+    std::string primaryMask)
+{
     // 如果 affineFormats 为空，直接返回 primaryMask
     if (maskOptions.affineFormats->size() <= 0) {
         auto mask = maskGetOrCreate(primaryMask, maskOptions.customNotations.value(), maskOptions.rightToLeft.value());
         int affinity = calculateAffinity(*mask, text, maskOptions.affinityCalculationStrategy.value());
-        DLOG(INFO) << " ======= pickMask calculateAffinity value： " << affinity
-                   << "\n affinityCalculationStrategy: " << maskOptions.affinityCalculationStrategy.value();
+        DLOG(INFO) << " ======= pickMask calculateAffinity value： " << affinity <<
+            "\n affinityCalculationStrategy: " << maskOptions.affinityCalculationStrategy.value();
         return mask;
     }
     // 定义 MaskAffinity 结构体，用于存储 Mask 和相应的亲和度
@@ -136,8 +148,8 @@ std::shared_ptr<Mask> RNTextInputMask::pickMask(const CaretString &text, MaskOpt
 
     // 计算 primaryMask 的亲和度
     int primaryAffinity = calculateAffinity(primaryMask, text, maskOptions.affinityCalculationStrategy.value());
-    DLOG(INFO) << " ======= pickMask calculateAffinity value： " << primaryAffinity << " \n mask: " << primaryMask
-               << "\n affinityCalculationStrategy: " << maskOptions.affinityCalculationStrategy.value();
+    DLOG(INFO) << " ======= pickMask calculateAffinity value： " << primaryAffinity << " \n mask: " << primaryMask <<
+        "\n affinityCalculationStrategy: " << maskOptions.affinityCalculationStrategy.value();
     // 存储所有 mask 和亲和度的列表
     std::vector<MaskAffinity> masksAndAffinities;
 
@@ -146,14 +158,14 @@ std::shared_ptr<Mask> RNTextInputMask::pickMask(const CaretString &text, MaskOpt
         std::shared_ptr<Mask> mask =
             maskGetOrCreate(format, maskOptions.customNotations.value(), maskOptions.rightToLeft.value());
         int affinity = calculateAffinity(*mask, text, maskOptions.affinityCalculationStrategy.value());
-        DLOG(INFO) << " ======= pickMask calculateAffinity value： " << affinity << "\n affineFormat: " << format
-                   << "\n affinityCalculationStrategy: " << maskOptions.affinityCalculationStrategy.value();
+        DLOG(INFO) << " ======= pickMask calculateAffinity value： " << affinity << "\n affineFormat: " << format <<
+            "\n affinityCalculationStrategy: " << maskOptions.affinityCalculationStrategy.value();
         masksAndAffinities.emplace_back(*mask, affinity);
     }
 
     // 按亲和度降序排序
     std::sort(masksAndAffinities.begin(), masksAndAffinities.end(),
-              [](const MaskAffinity &a, const MaskAffinity &b) { return a.affinity > b.affinity; });
+        [](const MaskAffinity &a, const MaskAffinity &b) { return a.affinity > b.affinity; });
 
     // 寻找插入位置
     int insertIndex = -1;
@@ -175,7 +187,8 @@ std::shared_ptr<Mask> RNTextInputMask::pickMask(const CaretString &text, MaskOpt
     return std::make_shared<Mask>(masksAndAffinities.front().mask);
 }
 
-void RNTextInputMask::setMask(int reactNode, std::string primaryFormat, MaskOptions maskOptions) {
+void RNTextInputMask::setMask(int reactNode, std::string primaryFormat, MaskOptions maskOptions)
+{
     auto task = [this, reactNode, primaryFormat, maskOptions] {
         auto weakInstance = m_ctx.instance;
         auto instance = weakInstance.lock();
@@ -193,24 +206,24 @@ void RNTextInputMask::setMask(int reactNode, std::string primaryFormat, MaskOpti
         }
         ArkUINode &node = input->getLocalRootArkUINode();
         TextInputNode *textInputNode = dynamic_cast<TextInputNode *>(&node);
-        UserData *userData = new UserData({.data = textInputNode->getArkUINodeHandle(),
-                                           .maskOptions = maskOptions,
-                                           .primaryFormat = primaryFormat,
-                                           .node = reactNode,
-                                           .instance = this});
+        UserData *userData = new UserData({
+            .data = textInputNode->getArkUINodeHandle(),
+            .maskOptions = maskOptions,
+            .primaryFormat = primaryFormat,
+            .node = reactNode,
+            .instance = this });
         NativeNodeApi::getInstance()->registerNodeEvent(textInputNode->getArkUINodeHandle(), NODE_TEXT_INPUT_ON_CHANGE,
-                                                        reactNode, textInputNode);
+            reactNode, textInputNode);
         NativeNodeApi::getInstance()->registerNodeEvent(textInputNode->getArkUINodeHandle(), NODE_ON_FOCUS, 111,
-                                                        textInputNode);
+            textInputNode);
         this->m_userDatas.insert(userData);
         NativeNodeApi::getInstance()->setUserData(textInputNode->getArkUINodeHandle(), userData);
         NativeNodeApi::getInstance()->addNodeEventReceiver(textInputNode->getArkUINodeHandle(), myEventReceiver);
     };
     this->m_ctx.taskExecutor->runTask(TaskThread::MAIN, std::move(task));
 }
-
-std::string getString(std::string maskValue, std::string value, bool autocomplete, bool isMask) {
-
+std::string getString(std::string maskValue, std::string value, bool autocomplete, bool isMask)
+{
     auto maskObj = Mask::MaskFactory::getOrCreate(maskValue, {});
     CaretString text(value, value.length(), std::make_shared<CaretString::Forward>(autocomplete));
     auto r = maskObj->apply(text);
@@ -222,32 +235,14 @@ std::string getString(std::string maskValue, std::string value, bool autocomplet
     }
     return result;
 }
-
-std::string getString(std::string maskValue, std::string value, bool autocomplete, bool isMask, bool rightToLeft) {
-    std::shared_ptr<Mask> maskObj;
-    if (rightToLeft) {
-        maskObj = RTLMask::getOrCreate(maskValue, {});
-    } else {
-        maskObj = Mask::MaskFactory::getOrCreate(maskValue, {});
-    }
-    CaretString text(value, value.length(), std::make_shared<CaretString::Forward>(autocomplete));
-    auto r = maskObj->apply(text);
-    std::string result;
-    if (isMask) {
-        result = r.formattedText.string;
-    } else {
-        result = r.extractedValue;
-    }
-    return result;
-}
-
 static jsi::Value __hostFunction_RNTextInputMask_unmask(jsi::Runtime &rt, react::TurboModule &turboModule,
-                                                        const jsi::Value *args, size_t count) {
+    const jsi::Value *args, size_t count)
+{
     std::string maskValue = args[0].getString(rt).utf8(rt);
     std::string value = args[1].getString(rt).utf8(rt);
     bool autocomplete = args[2].getBool();
-    return createPromiseAsJSIValue(
-        rt, [maskValue, value, autocomplete](jsi::Runtime &rt2, std::shared_ptr<facebook::react::Promise> promise) {
+    return createPromiseAsJSIValue(rt,
+        [maskValue, value, autocomplete](jsi::Runtime &rt2, std::shared_ptr<facebook::react::Promise> promise) {
             try {
                 auto start = std::chrono::high_resolution_clock::now();
                 std::string result = getString(maskValue, value, autocomplete, 0);
@@ -262,37 +257,14 @@ static jsi::Value __hostFunction_RNTextInputMask_unmask(jsi::Runtime &rt, react:
             }
         });
 }
-
-static jsi::Value __hostFunction_RNTextInputMask_unmaskWithRightToLeft(jsi::Runtime &rt, react::TurboModule &turboModule,
-                                                        const jsi::Value *args, size_t count) {
-    std::string maskValue = args[0].getString(rt).utf8(rt);
-    std::string value = args[1].getString(rt).utf8(rt);
-    bool autocomplete = args[2].getBool();
-    bool rightToLeft = args[3].getBool();
-    return createPromiseAsJSIValue(
-        rt, [maskValue, value, autocomplete, rightToLeft](jsi::Runtime &rt2, std::shared_ptr<facebook::react::Promise> promise) {
-            try {
-                auto start = std::chrono::high_resolution_clock::now();
-                std::string result = getString(maskValue, value, autocomplete, 0, rightToLeft);
-                promise->resolve(jsi::String::createFromUtf8(rt2, result));
-                // 获取结束时间点
-                auto end = std::chrono::high_resolution_clock::now();
-                // 计算延迟
-                std::chrono::duration<double, std::milli> latency = end - start;
-                DLOG(INFO) << "=======unmask 响应时长: " << latency.count() << " 毫秒" << std::endl;
-            } catch (FormatError e) {
-                promise->reject(e.what());
-            }
-        });
-}
-
 static jsi::Value __hostFunction_RNTextInputMask_mask(jsi::Runtime &rt, react::TurboModule &turboModule,
-                                                      const jsi::Value *args, size_t count) {
+    const jsi::Value *args, size_t count)
+{
     std::string maskValue = args[0].getString(rt).utf8(rt);
     std::string value = args[1].getString(rt).utf8(rt);
     bool autocomplete = args[2].getBool();
-    return createPromiseAsJSIValue(
-        rt, [maskValue, value, autocomplete](jsi::Runtime &rt2, std::shared_ptr<facebook::react::Promise> promise) {
+    return createPromiseAsJSIValue(rt,
+        [maskValue, value, autocomplete](jsi::Runtime &rt2, std::shared_ptr<facebook::react::Promise> promise) {
             try {
                 auto start = std::chrono::high_resolution_clock::now();
                 std::string result = getString(maskValue, value, autocomplete, 1);
@@ -307,10 +279,9 @@ static jsi::Value __hostFunction_RNTextInputMask_mask(jsi::Runtime &rt, react::T
             }
         });
 }
-
 static jsi::Value __hostFunction_RNTextInputMask_setMask(jsi::Runtime &rt, react::TurboModule &turboModule,
-                                                         const jsi::Value *args, size_t count) {
-
+    const jsi::Value *args, size_t count)
+{
     auto turbo = static_cast<RNTextInputMask *>(&turboModule);
     if (turbo->grt == nullptr) {
         turbo->grt = &rt;
@@ -330,8 +301,8 @@ static jsi::Value __hostFunction_RNTextInputMask_setMask(jsi::Runtime &rt, react
             for (size_t i = 0; i < length; ++i) {
                 // 获取数组元素
                 jsi::Value value = arrayAffineFormats.getValueAtIndex(rt, i);
-                std::cout << "===affineFormats index" + std::to_string(i) << "--" << value.getString(rt).utf8(rt)
-                          << std::endl;
+                std::cout << "===affineFormats index" + std::to_string(i) << "--" << value.getString(rt).utf8(rt) <<
+                    std::endl;
                 affineFormatsValues.push_back(value.getString(rt).utf8(rt));
             }
         } else {
@@ -369,8 +340,6 @@ static jsi::Value __hostFunction_RNTextInputMask_setMask(jsi::Runtime &rt, react
             std::cerr << "====The property 'myArray' is not an array." << std::endl;
         }
     }
-
-
     std::string affinityCalculationStrategy;
     if (obj.hasProperty(rt, "affinityCalculationStrategy") &&
         !obj.getProperty(rt, "affinityCalculationStrategy").isUndefined()) {
@@ -393,20 +362,20 @@ static jsi::Value __hostFunction_RNTextInputMask_setMask(jsi::Runtime &rt, react
     }
 
     auto maskOptions = new MaskOptions(affineFormatsValues, customNotationsValues, affinityCalculationStrategy,
-                                       autocomplete, autoskip, rightToLeft);
+        autocomplete, autoskip, rightToLeft);
     static_cast<RNTextInputMask *>(&turboModule)->setMask(reactNode, primaryFormat, *maskOptions);
     return jsi::Value::undefined();
 }
 
 RNTextInputMask::RNTextInputMask(const ArkTSTurboModule::Context ctx, const std::string name)
-    : ArkTSTurboModule(ctx, name) {
-    methodMap_["setMask"] = MethodMetadata{3, __hostFunction_RNTextInputMask_setMask};
-    methodMap_["mask"] = MethodMetadata{3, __hostFunction_RNTextInputMask_mask};
-    methodMap_["unmask"] = MethodMetadata{3, __hostFunction_RNTextInputMask_unmask};
-    methodMap_["unmaskWithRightToLeft"] = MethodMetadata{4, __hostFunction_RNTextInputMask_unmaskWithRightToLeft};
+    : ArkTSTurboModule(ctx, name)
+{
+    methodMap_["setMask"] = MethodMetadata{ 3, __hostFunction_RNTextInputMask_setMask };
+    methodMap_["mask"] = MethodMetadata{ 3, __hostFunction_RNTextInputMask_mask };
+    methodMap_["unmask"] = MethodMetadata{ 3, __hostFunction_RNTextInputMask_unmask };
 }
-
-RNTextInputMask::~RNTextInputMask() {
+RNTextInputMask::~RNTextInputMask()
+{
     for (auto userData : m_userDatas) {
         if (userData != nullptr) {
             NativeNodeApi::getInstance()->unregisterNodeEvent(userData->data, NODE_TEXT_INPUT_ON_CHANGE);

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

@@ -12,6 +12,8 @@
  *
  * @generatorVersion: 1
  */
+#ifndef RNTEXTINPUTMASK_H
+#define RNTEXTINPUTMASK_H
 #pragma once
 
 #include "RNOH/ArkTSTurboModule.h"
@@ -37,7 +39,8 @@ struct MaskParams {
     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) {
+    MaskParams &operator=(const MaskParams &input)
+    {
         this->mask = input.mask;
         this->value = input.value;
         this->autocomplete = input.autocomplete;
@@ -55,12 +58,13 @@ struct MaskOptions {
 
     MaskOptions()
         : affineFormats(std::vector<std::string>()), customNotations(std::vector<Notation>()),
-          affinityCalculationStrategy(std::nullopt), autocomplete(true), autoskip(false), rightToLeft(false) {}
+        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)
+        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) {}
+        affinityCalculationStrategy(strategy.empty() ?
+            std::make_optional("WHOLE_STRING") : std::make_optional(strategy)),
+        autocomplete(autoComp), autoskip(autoSkip), rightToLeft(rtl) {}
 };
 
 typedef struct {
@@ -78,16 +82,13 @@ public:
     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
+#endif

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

@@ -13,7 +13,8 @@ using namespace facebook;
 namespace rnoh {
 class RNTextInputMaskTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
 public:
-    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override
+    {
         if (name == "RNTextInputMask") {
             return std::make_shared<RNTextInputMask>(ctx, name);
         }
@@ -24,7 +25,8 @@ public:
 class RNTextInputMaskPackage : public Package {
 public:
     RNTextInputMaskPackage(Package::Context ctx) : Package(ctx) {}
-    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override {
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override
+    {
         return std::make_unique<RNTextInputMaskTurboModuleFactoryDelegate>();
     }
     // std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;

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

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef COMPILER_H
+#define COMPILER_H
 #pragma once
 #include <string>
 #include <vector>
@@ -23,86 +24,86 @@ private:
     std::vector<Notation> customNotations;
 
 public:
-    Compiler(const std::vector<Notation> &notations) : customNotations(notations) {}
+    explicit Compiler(const std::vector<Notation> &notations) : customNotations(notations) {}
 
-    std::shared_ptr<State> compile(const std::string &formatString) {
+    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) {
+    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 '[':
+                if (lastCharacter != '\\') {
+                    return compile(formatString.substr(1), true, false, ch);
+                }
+                break;
 
-        case ']':
-        case '}':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), false, false, ch);
-            }
-            break;
+            case '{':
+                if (lastCharacter != '\\') {
+                    return compile(formatString.substr(1), false, true, ch);
+                }
+                break;
 
-        case '\\':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), valuable, fixed, ch);
-            }
-            break;
+            case ']':
+            case '}':
+                if (lastCharacter != '\\') {
+                    return compile(formatString.substr(1), false, false, ch);
+                }
+                break;
 
-        default:
-            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 '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 '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_shared<ValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                        std::make_shared<ValueState::AlphaNumeric>());
 
-            case '...':
-                return std::make_unique<ValueState>(determineInheritedType(lastCharacter));
+                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 '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 '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>());
+                case '-':
+                    return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                                std::make_shared<OptionalValueState::AlphaNumeric>());
 
-            default:
-                return compileWithCustomNotations(ch, formatString);
-            }
+                default:
+                    return compileWithCustomNotations(ch, formatString);
+                }
         }
         if (fixed) {
             return std::make_shared<FixedState>(compile(formatString.substr(1), false, true, ch), ch);
@@ -110,18 +111,21 @@ public:
         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();
+    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;
+                    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;
+                    DLOG(ERROR) << "======= compileWithCustomNotations  customNotations isOptional :"
+                    << customNotation.isOptional;
                     return std::make_unique<ValueState>(
                         std::move(compiledState), std::make_shared<ValueState::Custom>(c, customNotation.characterSet));
                 }
@@ -130,46 +134,45 @@ public:
         DLOG(INFO) << "compileWithCustomNotations No Match Found ";
         throw FormatError("compileWithCustomNotations No Match Found");
     }
-    std::shared_ptr<ValueState::ValueStateType> determineInheritedType(std::optional<char> lastCharacter) {
+    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);
+            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) {
+    std::shared_ptr<ValueState::ValueStateType> determineTypeWithCustomNotations(std::optional<char> lastCharacter)
+    {
         if (!lastCharacter.has_value()) {
             throw FormatError(); // 处理空字符情况，抛出异常
         }
-         DLOG(INFO) << "======determineTypeWithCustomNotations customNotations size: "<<customNotations.size();
+        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); // 可以根据需要调整返回内容
+                    customNotation.characterSet); // 可以根据需要调整返回内容
             }
         }
         DLOG(INFO) << "determineTypeWithCustomNotations No Match Found ";
         throw FormatError("determineTypeWithCustomNotations No Match Found"); // 未找到匹配项，抛出异常
     }
 };
-} // namespace TinpMask
+} // namespace TinpMask
+#endif