@salve-software/react-native-nitro-input-mask 1.0.0 → 1.1.0

package/lib/typescript/src/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,qBAAqB,CAAC;AACzC,mBAAmB,cAAc,CAAC;AAClC,mBAAmB,oBAAoB,CAAC;AACxC,mBAAmB,yBAAyB,CAAC;AAC7C,mBAAmB,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,qBAAqB,CAAC;AACzC,mBAAmB,cAAc,CAAC;AAClC,mBAAmB,cAAc,CAAC;AAClC,mBAAmB,oBAAoB,CAAC;AACxC,mBAAmB,yBAAyB,CAAC;AAC7C,mBAAmB,uBAAuB,CAAC"}

package/nitrogen/generated/android/c++/JHybridNitroInputMaskServiceSpec.cpp

@@ -7,9 +7,13 @@
 
 #include "JHybridNitroInputMaskServiceSpec.hpp"
 
+// Forward declaration of `MaskResult` to properly resolve imports.
+namespace margelo::nitro::nitroinputmask { struct MaskResult; }
 // Forward declaration of `NitroMaskOptions` to properly resolve imports.
 namespace margelo::nitro::nitroinputmask { struct NitroMaskOptions; }
 
+#include "MaskResult.hpp"
+#include "JMaskResult.hpp"
 #include <string>
 #include "NitroMaskOptions.hpp"
 #include "JNitroMaskOptions.hpp"
@@ -48,10 +52,10 @@ namespace margelo::nitro::nitroinputmask {
   
 
   // Methods
-  std::string JHybridNitroInputMaskServiceSpec::applyMask(const std::string& value, const std::string& maskType, const NitroMaskOptions& options) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* value */, jni::alias_ref<jni::JString> /* maskType */, jni::alias_ref<JNitroMaskOptions> /* options */)>("applyMask");
+  MaskResult JHybridNitroInputMaskServiceSpec::applyMask(const std::string& value, const std::string& maskType, const NitroMaskOptions& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JMaskResult>(jni::alias_ref<jni::JString> /* value */, jni::alias_ref<jni::JString> /* maskType */, jni::alias_ref<JNitroMaskOptions> /* options */)>("applyMask");
     auto __result = method(_javaPart, jni::make_jstring(value), jni::make_jstring(maskType), JNitroMaskOptions::fromCpp(options));
-    return __result->toStdString();
+    return __result->toCpp();
   }
 
 } // namespace margelo::nitro::nitroinputmask

package/nitrogen/generated/android/c++/JHybridNitroInputMaskServiceSpec.hpp

@@ -54,7 +54,7 @@ namespace margelo::nitro::nitroinputmask {
 
   public:
     // Methods
-    std::string applyMask(const std::string& value, const std::string& maskType, const NitroMaskOptions& options) override;
+    MaskResult applyMask(const std::string& value, const std::string& maskType, const NitroMaskOptions& options) override;
 
   private:
     jni::global_ref<JHybridNitroInputMaskServiceSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/c++/JMaskResult.hpp

@@ -0,0 +1,61 @@
+///
+/// JMaskResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MaskResult.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitroinputmask {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MaskResult" and the the Kotlin data class "MaskResult".
+   */
+  struct JMaskResult final: public jni::JavaClass<JMaskResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroinputmask/MaskResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MaskResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MaskResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMasked = clazz->getField<jni::JString>("masked");
+      jni::local_ref<jni::JString> masked = this->getFieldValue(fieldMasked);
+      static const auto fieldRaw = clazz->getField<jni::JString>("raw");
+      jni::local_ref<jni::JString> raw = this->getFieldValue(fieldRaw);
+      return MaskResult(
+        masked->toStdString(),
+        raw->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMaskResult::javaobject> fromCpp(const MaskResult& value) {
+      using JSignature = JMaskResult(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.masked),
+        jni::make_jstring(value.raw)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroinputmask

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroinputmask/HybridNitroInputMaskServiceSpec.kt

@@ -30,7 +30,7 @@ abstract class HybridNitroInputMaskServiceSpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun applyMask(value: String, maskType: String, options: NitroMaskOptions): String
+  abstract fun applyMask(value: String, maskType: String, options: NitroMaskOptions): MaskResult
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroinputmask/MaskResult.kt

@@ -0,0 +1,56 @@
+///
+/// MaskResult.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroinputmask
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "MaskResult".
+ */
+@DoNotStrip
+@Keep
+data class MaskResult(
+  @DoNotStrip
+  @Keep
+  val masked: String,
+  @DoNotStrip
+  @Keep
+  val raw: String
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is MaskResult) return false
+    return Objects.deepEquals(this.masked, other.masked)
+      && Objects.deepEquals(this.raw, other.raw)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf(
+      masked,
+      raw
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(masked: String, raw: String): MaskResult {
+      return MaskResult(masked, raw)
+    }
+  }
+}

package/nitrogen/generated/ios/NitroInputMask-Swift-Cxx-Bridge.hpp

@@ -12,6 +12,8 @@
 namespace margelo::nitro::nitroinputmask { class HybridNitroInputMaskServiceSpec; }
 // Forward declaration of `HybridNitroInputMaskSpec` to properly resolve imports.
 namespace margelo::nitro::nitroinputmask { class HybridNitroInputMaskSpec; }
+// Forward declaration of `MaskResult` to properly resolve imports.
+namespace margelo::nitro::nitroinputmask { struct MaskResult; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridNitroInputMaskServiceSpec_cxx` to properly resolve imports.
@@ -22,6 +24,7 @@ namespace NitroInputMask { class HybridNitroInputMaskSpec_cxx; }
 // Include C++ defined types
 #include "HybridNitroInputMaskServiceSpec.hpp"
 #include "HybridNitroInputMaskSpec.hpp"
+#include "MaskResult.hpp"
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <memory>
@@ -91,13 +94,13 @@ namespace margelo::nitro::nitroinputmask::bridge::swift {
   using std__weak_ptr_HybridNitroInputMaskServiceSpec_ = std::weak_ptr<HybridNitroInputMaskServiceSpec>;
   inline std__weak_ptr_HybridNitroInputMaskServiceSpec_ weakify_std__shared_ptr_HybridNitroInputMaskServiceSpec_(const std::shared_ptr<HybridNitroInputMaskServiceSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: Result<std::string>
-  using Result_std__string_ = Result<std::string>;
-  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
-    return Result<std::string>::withValue(value);
+  // pragma MARK: Result<MaskResult>
+  using Result_MaskResult_ = Result<MaskResult>;
+  inline Result_MaskResult_ create_Result_MaskResult_(const MaskResult& value) noexcept {
+    return Result<MaskResult>::withValue(value);
   }
-  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
-    return Result<std::string>::withError(error);
+  inline Result_MaskResult_ create_Result_MaskResult_(const std::exception_ptr& error) noexcept {
+    return Result<MaskResult>::withError(error);
   }
   
   // pragma MARK: std::shared_ptr<HybridNitroInputMaskSpec>

package/nitrogen/generated/ios/NitroInputMask-Swift-Cxx-Umbrella.hpp

@@ -12,12 +12,15 @@
 namespace margelo::nitro::nitroinputmask { class HybridNitroInputMaskServiceSpec; }
 // Forward declaration of `HybridNitroInputMaskSpec` to properly resolve imports.
 namespace margelo::nitro::nitroinputmask { class HybridNitroInputMaskSpec; }
+// Forward declaration of `MaskResult` to properly resolve imports.
+namespace margelo::nitro::nitroinputmask { struct MaskResult; }
 // Forward declaration of `NitroMaskOptions` to properly resolve imports.
 namespace margelo::nitro::nitroinputmask { struct NitroMaskOptions; }
 
 // Include C++ defined types
 #include "HybridNitroInputMaskServiceSpec.hpp"
 #include "HybridNitroInputMaskSpec.hpp"
+#include "MaskResult.hpp"
 #include "NitroMaskOptions.hpp"
 #include <NitroModules/Result.hpp>
 #include <exception>

package/nitrogen/generated/ios/c++/HybridNitroInputMaskServiceSpecSwift.hpp

@@ -12,9 +12,12 @@
 // Forward declaration of `HybridNitroInputMaskServiceSpec_cxx` to properly resolve imports.
 namespace NitroInputMask { class HybridNitroInputMaskServiceSpec_cxx; }
 
+// Forward declaration of `MaskResult` to properly resolve imports.
+namespace margelo::nitro::nitroinputmask { struct MaskResult; }
 // Forward declaration of `NitroMaskOptions` to properly resolve imports.
 namespace margelo::nitro::nitroinputmask { struct NitroMaskOptions; }
 
+#include "MaskResult.hpp"
 #include <string>
 #include "NitroMaskOptions.hpp"
 #include <optional>
@@ -69,7 +72,7 @@ namespace margelo::nitro::nitroinputmask {
 
   public:
     // Methods
-    inline std::string applyMask(const std::string& value, const std::string& maskType, const NitroMaskOptions& options) override {
+    inline MaskResult applyMask(const std::string& value, const std::string& maskType, const NitroMaskOptions& options) override {
       auto __result = _swiftPart.applyMask(value, maskType, std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/HybridNitroInputMaskServiceSpec.swift

@@ -13,7 +13,7 @@ public protocol HybridNitroInputMaskServiceSpec_protocol: HybridObject {
   
 
   // Methods
-  func applyMask(value: String, maskType: String, options: NitroMaskOptions) throws -> String
+  func applyMask(value: String, maskType: String, options: NitroMaskOptions) throws -> MaskResult
 }
 
 public extension HybridNitroInputMaskServiceSpec_protocol {

package/nitrogen/generated/ios/swift/HybridNitroInputMaskServiceSpec_cxx.swift

@@ -125,14 +125,14 @@ open class HybridNitroInputMaskServiceSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func applyMask(value: std.string, maskType: std.string, options: NitroMaskOptions) -> bridge.Result_std__string_ {
+  public final func applyMask(value: std.string, maskType: std.string, options: NitroMaskOptions) -> bridge.Result_MaskResult_ {
     do {
       let __result = try self.__implementation.applyMask(value: String(value), maskType: String(maskType), options: options)
-      let __resultCpp = std.string(__result)
-      return bridge.create_Result_std__string_(__resultCpp)
+      let __resultCpp = __result
+      return bridge.create_Result_MaskResult_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__string_(__exceptionPtr)
+      return bridge.create_Result_MaskResult_(__exceptionPtr)
     }
   }
 }

package/nitrogen/generated/ios/swift/MaskResult.swift

@@ -0,0 +1,34 @@
+///
+/// MaskResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `MaskResult`, backed by a C++ struct.
+ */
+public typealias MaskResult = margelo.nitro.nitroinputmask.MaskResult
+
+public extension MaskResult {
+  private typealias bridge = margelo.nitro.nitroinputmask.bridge.swift
+
+  /**
+   * Create a new instance of `MaskResult`.
+   */
+  init(masked: String, raw: String) {
+    self.init(std.string(masked), std.string(raw))
+  }
+
+  @inline(__always)
+  var masked: String {
+    return String(self.__masked)
+  }
+  
+  @inline(__always)
+  var raw: String {
+    return String(self.__raw)
+  }
+}

package/nitrogen/generated/shared/c++/HybridNitroInputMaskServiceSpec.hpp

@@ -13,9 +13,12 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `MaskResult` to properly resolve imports.
+namespace margelo::nitro::nitroinputmask { struct MaskResult; }
 // Forward declaration of `NitroMaskOptions` to properly resolve imports.
 namespace margelo::nitro::nitroinputmask { struct NitroMaskOptions; }
 
+#include "MaskResult.hpp"
 #include <string>
 #include "NitroMaskOptions.hpp"
 
@@ -50,7 +53,7 @@ namespace margelo::nitro::nitroinputmask {
 
     public:
       // Methods
-      virtual std::string applyMask(const std::string& value, const std::string& maskType, const NitroMaskOptions& options) = 0;
+      virtual MaskResult applyMask(const std::string& value, const std::string& maskType, const NitroMaskOptions& options) = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/MaskResult.hpp

@@ -0,0 +1,87 @@
+///
+/// MaskResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::nitroinputmask {
+
+  /**
+   * A struct which can be represented as a JavaScript object (MaskResult).
+   */
+  struct MaskResult final {
+  public:
+    std::string masked     SWIFT_PRIVATE;
+    std::string raw     SWIFT_PRIVATE;
+
+  public:
+    MaskResult() = default;
+    explicit MaskResult(std::string masked, std::string raw): masked(masked), raw(raw) {}
+
+  public:
+    friend bool operator==(const MaskResult& lhs, const MaskResult& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitroinputmask
+
+namespace margelo::nitro {
+
+  // C++ MaskResult <> JS MaskResult (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroinputmask::MaskResult> final {
+    static inline margelo::nitro::nitroinputmask::MaskResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitroinputmask::MaskResult(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "masked"))),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "raw")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroinputmask::MaskResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "masked"), JSIConverter<std::string>::toJSI(runtime, arg.masked));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "raw"), JSIConverter<std::string>::toJSI(runtime, arg.raw));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "masked")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "raw")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salve-software/react-native-nitro-input-mask",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "High-performance native input masks for React Native built with Nitro Modules. Phone, currency, CPF, credit card and custom masks with zero JS flicker.",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -63,7 +63,8 @@
   "homepage": "https://github.com/Salve-Software/react-native-nitro-input-mask#readme",
   "publishConfig": {
     "access": "public",
-    "registry": "https://registry.npmjs.org/"
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
   },
   "devDependencies": {
     "@jamesacarr/eslint-formatter-github-actions": "^0.2.0",

package/src/classes/NitroInputMaskService/NitroInputMaskService.class.ts

@@ -1,4 +1,5 @@
 import type { IApplyMaskProps } from './types';
+import type { MaskResult } from '../../types';
 import { getNitroServiceModule } from '../../nitro-module';
 
 /**
@@ -8,23 +9,25 @@ import { getNitroServiceModule } from '../../nitro-module';
  * plain function call — no component or ref required.
  *
  * @example
- * const masked = NitroInputMaskService.applyMask({
+ * const { masked, raw } = NitroInputMaskService.applyMask({
  *   value: '12345678901',
  *   maskOptions: { mask: '999.999.999-99' },
  * })
- * // '123.456.789-01'
+ * // masked: '123.456.789-01'
+ * // raw:    '12345678901'
  *
  * @example
- * const masked = NitroInputMaskService.applyMask({
+ * const { masked, raw } = NitroInputMaskService.applyMask({
  *   value: '123456',
  *   maskType: 'money',
  *   maskOptions: { unit: 'R$ ', precision: 2 },
  * })
- * // 'R$ 1.234,56'
+ * // masked: 'R$ 1.234,56'
+ * // raw:    '123456'  (digit-only string for money masks)
  */
 export class NitroInputMaskService {
   /**
-   * Applies a mask to a string and returns the masked result.
+   * Applies a mask to a string and returns both the masked and raw values.
    *
    * For `custom` masks, tokens are:
    * - `9` — digit (0–9)
@@ -36,18 +39,19 @@ export class NitroInputMaskService {
    * @param props.value       - The raw string to mask.
    * @param props.maskType    - The mask type: `'custom'` (default), `'money'`, `'datetime'`, `'credit-card'`.
    * @param props.maskOptions - Options specific to the chosen mask type.
-   * @returns The masked string.
+   * @returns `{ masked, raw }` — the formatted string and the unformatted input.
+   *          For money masks, `raw` is a digit-only string.
    *
    * @throws If `value` exceeds 1000 characters or `custom` mask exceeds 200 characters.
    *
    * @example
-   * NitroInputMaskService.applyMask({
+   * const { masked } = NitroInputMaskService.applyMask({
    *   value: '11987654321',
    *   maskOptions: { mask: '(99) 99999-9999' },
    * })
-   * // '(11) 98765-4321'
+   * // masked: '(11) 98765-4321'
    */
-  static applyMask = (props: IApplyMaskProps): string => {
+  static applyMask = (props: IApplyMaskProps): MaskResult => {
     const { value, maskType, maskOptions } = props as IApplyMaskProps & {
       maskType?: string;
       maskOptions?: Record<string, unknown>;
@@ -57,9 +61,13 @@ export class NitroInputMaskService {
     const resolvedMaskType = maskType ?? 'custom';
     const resolvedOptions = maskOptions ?? {};
 
+    if (resolvedValue.length > 1000) {
+      throw new Error('NitroInputMaskService: value exceeds maximum allowed length');
+    }
+
     if (resolvedMaskType === 'custom') {
       const mask = String((resolvedOptions as { mask?: string }).mask ?? '');
-      if (!mask) return resolvedValue;
+      if (!mask) return { masked: resolvedValue, raw: resolvedValue };
       if (resolvedValue.length > 1000 || mask.length > 200) {
         throw new Error('NitroInputMaskService: value or mask exceeds maximum allowed length');
       }

package/src/components/NitroInputMask/index.tsx

@@ -1,38 +1,56 @@
 import type { NitroInputMaskProps } from './types';
-import React, { useEffect, useId } from 'react';
+import type { NitroMaskOptions } from '../../specs/nitro-input-mask.nitro';
+import React, { useCallback, useEffect, useId, useMemo, useRef } from 'react';
 import { TextInput } from 'react-native';
-import { nitroModule } from '../../nitro-module';
+import { nitroModule, getNitroServiceModule } from '../../nitro-module';
 
 export const NitroInputMask = (props: NitroInputMaskProps) => {
-  const { maskType, maskOptions, value, ...rest } = props as NitroInputMaskProps & {
-    maskType?: string;
-    maskOptions?: Record<string, unknown>;
-  };
+  const { maskType, maskOptions, onChangeText, value, ...rest } = props;
 
-  const resolvedMaskType = maskType ?? 'custom';
   const reactId = useId();
+
+  const resolvedMaskType = maskType ?? 'custom';
+  const resolvedOptions = (maskOptions ?? {}) as Record<string, unknown>;
   const id = `nitro-input-mask-${reactId}`;
+  const maskOptionsJson = JSON.stringify(resolvedOptions);
 
-  const maskOptionsJson = JSON.stringify(maskOptions ?? {});
+  const stableOptions: NitroMaskOptions = useMemo(() => JSON.parse(maskOptionsJson), [maskOptionsJson]);
+  const valueFromUserInput = useRef(false);
 
   useEffect(() => {
-    nitroModule.attach(id, resolvedMaskType, maskOptions ?? {});
+    nitroModule.attach(id, resolvedMaskType, stableOptions);
     if (value != null) nitroModule.setValue(id, String(value));
     return () => nitroModule.detach(id);
   }, []);
 
   useEffect(() => {
-    nitroModule.updateMask(id, resolvedMaskType, maskOptions ?? {});
+    nitroModule.updateMask(id, resolvedMaskType, stableOptions);
   }, [resolvedMaskType, maskOptionsJson]);
 
   useEffect(() => {
     if (value == null) return;
+
+    if (valueFromUserInput.current) {
+      valueFromUserInput.current = false;
+      return;
+    }
+
     nitroModule.setValue(id, String(value));
   }, [value]);
 
+  const handleChangeText = useCallback((text: string) => {
+    valueFromUserInput.current = true;
+    
+    if (onChangeText) {
+      const result = getNitroServiceModule().applyMask(text, resolvedMaskType, stableOptions);
+      onChangeText(result);
+    }
+  }, [onChangeText, resolvedMaskType, stableOptions]);
+
   return (
-    <TextInput
+    <TextInput 
       {...rest}
+      onChangeText={handleChangeText}
       nativeID={id}
     />
   )

package/src/components/NitroInputMask/types/NitroInputMaskProps.ts

@@ -1,4 +1,21 @@
 import type { TextInputProps } from 'react-native';
-import type { MaskConfig } from '../../../types';
+import type { MaskConfig, MaskResult } from '../../../types';
 
-export type NitroInputMaskProps = TextInputProps & MaskConfig;
+export type NitroInputMaskProps = Omit<TextInputProps, 'onChangeText'> & MaskConfig & {
+  /**
+   * Called on every edit with both the masked display value and the raw
+   * unformatted value, giving consumers a single callback for both.
+   *
+   * For money masks, `raw` is a digit-only string.
+   *
+   * @example
+   * <NitroInputMask
+   *   maskOptions={{ mask: '(999) 999-9999' }}
+   *   onChangeText={({ masked, raw }) => {
+   *     setDisplay(masked)
+   *     setDigits(raw)
+   *   }}
+   * />
+   */
+  onChangeText?: (result: MaskResult) => void
+}

package/src/specs/nitro-input-mask-service.nitro.ts

@@ -1,6 +1,14 @@
 import type { HybridObject } from 'react-native-nitro-modules'
 import type { NitroMaskOptions } from './nitro-input-mask.nitro'
 
+// Declared inline to ensure Nitro codegen can resolve the type without
+// cross-file imports, which some versions of nitrogen reject.
+// Keep in sync with src/types/MaskResult.ts.
+export interface MaskResult {
+  masked: string
+  raw: string
+}
+
 export interface NitroInputMaskService extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
-  applyMask(value: string, maskType: string, options: NitroMaskOptions): string
+  applyMask(value: string, maskType: string, options: NitroMaskOptions): MaskResult
 }

package/src/types/MaskResult.ts

@@ -0,0 +1,12 @@
+/**
+ * The result returned by `NitroInputMaskService.applyMask()` and
+ * delivered to `<NitroInputMask onChangeText />`.
+ *
+ * - `masked` — the formatted string as displayed to the user (e.g. `"(555) 123-4567"`)
+ * - `raw`    — the unformatted input stripped of mask literals.
+ *              For money masks this is a digit-only string (e.g. `"123456"`).
+ */
+export type MaskResult = {
+  masked: string
+  raw: string
+}

package/src/types/index.ts

@@ -1,5 +1,6 @@
 export type * from './CustomMaskOptions';
 export type * from './MaskConfig';
+export type * from './MaskResult';
 export type * from './MoneyMaskOptions';
 export type * from './CreditCardMaskOptions';
 export type * from './DatetimeMaskOptions';