react-native-transformer-text-input 0.1.0-alpha.0

package/android/src/main/jni/CMakeLists.txt

@@ -0,0 +1,62 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+set(LIB_LITERAL rntti)
+set(LIB_TARGET_NAME react_codegen_${LIB_LITERAL})
+
+set(LIB_ANDROID_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
+set(LIB_COMMON_DIR ${LIB_ANDROID_DIR}/../cpp)
+set(LIB_ANDROID_GENERATED_JNI_DIR ${LIB_ANDROID_DIR}/build/generated/source/codegen/jni)
+set(LIB_ANDROID_GENERATED_COMPONENTS_DIR ${LIB_ANDROID_GENERATED_JNI_DIR}/react/renderer/components/${LIB_LITERAL})
+set(REACT_NATIVE_WORKLETS_DIR ${LIB_ANDROID_DIR}/../node_modules/react-native-worklets)
+
+file(GLOB LIB_CUSTOM_SRCS CONFIGURE_DEPENDS *.cpp ${LIB_COMMON_DIR}/*.cpp)
+file(GLOB LIB_CODEGEN_SRCS CONFIGURE_DEPENDS ${LIB_ANDROID_GENERATED_JNI_DIR}/*.cpp ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}/*.cpp)
+
+add_library(
+  ${LIB_TARGET_NAME}
+  SHARED
+  ${LIB_CUSTOM_SRCS}
+  ${LIB_CODEGEN_SRCS}
+)
+
+target_include_directories(
+  ${LIB_TARGET_NAME}
+  PUBLIC
+  .
+  ${LIB_COMMON_DIR}
+  ${LIB_ANDROID_GENERATED_JNI_DIR}
+  ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}
+  "${REACT_COMMON_DIR}"
+  "${REACT_COMMON_DIR}/jsiexecutor"
+  "${REACT_NATIVE_WORKLETS_DIR}/Common/cpp"
+  "${REACT_NATIVE_WORKLETS_DIR}/android/src/main/cpp"
+)
+
+message(STATUS "ANDROID_NDK_BUILD_TYPE = ${ANDROID_NDK_BUILD_TYPE}")
+
+
+add_library(worklets SHARED IMPORTED)
+
+set_target_properties(
+  worklets
+  PROPERTIES
+    IMPORTED_LOCATION
+    "${REACT_NATIVE_WORKLETS_DIR}/android/build/intermediates/cmake/debug/obj/${ANDROID_ABI}/libworklets.so"
+)
+
+target_link_libraries(
+  ${LIB_TARGET_NAME}
+  fbjni
+  jsi
+  reactnative
+  worklets
+)
+
+target_include_directories(
+  ${CMAKE_PROJECT_NAME}
+  PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_compile_reactnative_options(${LIB_TARGET_NAME} PUBLIC)

package/android/src/main/jni/TransformerTextInputJni.cpp

@@ -0,0 +1,94 @@
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/android/WorkletsModule.h>
+
+#include "TransformerTextInputRuntime.h"
+
+#include <memory>
+
+using namespace facebook;
+
+namespace rntti {
+
+struct JTextSelection : public jni::JavaClass<JTextSelection> {
+  static auto constexpr kJavaDescriptor =
+      "Lcom/appandflow/transformertextinput/TextSelection;";
+
+  static jni::local_ref<JTextSelection> create(int start, int end) {
+    return newInstance(start, end);
+  }
+};
+
+struct JTextState : public jni::JavaClass<JTextState> {
+  static auto constexpr kJavaDescriptor =
+      "Lcom/appandflow/transformertextinput/TextState;";
+
+  static jni::local_ref<JTextState> create(
+      std::string const &value,
+      jni::local_ref<JTextSelection> selection) {
+    return newInstance(value, selection);
+  }
+};
+
+class JTransformerTextInputJni
+    : public jni::HybridClass<JTransformerTextInputJni> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/appandflow/transformertextinput/TransformerTextInputJni;";
+
+  static void setWorkletsModule(
+      jni::alias_ref<jni::JClass> jClazz,
+      jni::alias_ref<worklets::WorkletsModule::javaobject> module) {
+    if (!module) {
+      return;
+    }
+    auto proxy = module->cthis()->getWorkletsModuleProxy();
+    if (!proxy) {
+      return;
+    }
+    auto uiRuntime = proxy->getUIWorkletRuntime();
+    if (!uiRuntime) {
+      return;
+    }
+    rntti::SetUIWorkletRuntime(uiRuntime);
+  }
+
+  static jni::local_ref<JTextState> transform(
+      jni::alias_ref<jni::JClass> jClazz,
+      jint transformerId,
+      jni::alias_ref<jni::JString> value,
+      jint selectionStart,
+      jint selectionEnd) {
+    auto transformer = rntti::LookupTransformer(transformerId);
+    if (!transformer) {
+      return nullptr;
+    }
+    const auto currentValue = value->toStdString();
+    rntti::SelectionRange selection{
+        static_cast<int>(selectionStart), static_cast<int>(selectionEnd)};
+    auto result = rntti::RunTransformer(transformer, currentValue, selection);
+    if (!result) {
+      return nullptr;
+    }
+
+    return JTextState::create(
+        result->value,
+        JTextSelection::create(result->selection.start, result->selection.end));
+  }
+
+  static void registerNatives() {
+    registerHybrid({
+        makeNativeMethod(
+            "setWorkletsModule", JTransformerTextInputJni::setWorkletsModule),
+        makeNativeMethod("transform", JTransformerTextInputJni::transform),
+    });
+  }
+};
+
+} // namespace rntti
+
+JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(
+      vm, [] { rntti::JTransformerTextInputJni::registerNatives(); });
+}

package/android/src/main/jni/rntti.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+#include "TransformerTextInputDecoratorViewComponentDescriptor.h"
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> rntti_ModuleProvider(
+    const std::string &moduleName,
+    const JavaTurboModule::InitParams &params);
+
+} // namespace react
+} // namespace facebook

package/cpp/TransformerTextInputDecoratorViewComponentDescriptor.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+#include "TransformerTextInputDecoratorViewShadowNode.h"
+
+namespace facebook::react {
+
+class TransformerTextInputDecoratorViewComponentDescriptor final
+    : public ConcreteComponentDescriptor<
+          TransformerTextInputDecoratorViewShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+};
+
+} // namespace facebook::react

package/cpp/TransformerTextInputDecoratorViewShadowNode.cpp

@@ -0,0 +1,21 @@
+#include "TransformerTextInputDecoratorViewShadowNode.h"
+
+namespace facebook::react {
+
+const char TransformerTextInputDecoratorViewComponentName[] =
+    "TransformerTextInputDecoratorView";
+
+void TransformerTextInputDecoratorViewShadowNode::initialize() {
+  // Setting display: contents style results in ForceFlattenView trait being set
+  // on the shadow node. This trait causes the node not to have a host view. By
+  // removing the trait, it's possible to force RN to create a host view, layout
+  // of which can then be customized.
+  ShadowNode::traits_.unset(ShadowNodeTraits::ForceFlattenView);
+}
+
+void TransformerTextInputDecoratorViewShadowNode::layout(
+    LayoutContext layoutContext) {
+  ConcreteViewShadowNode::layout(layoutContext);
+}
+
+} // namespace facebook::react

package/cpp/TransformerTextInputDecoratorViewShadowNode.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <react/renderer/components/rntti/EventEmitters.h>
+#include <react/renderer/components/rntti/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/ShadowNodeFamily.h>
+
+namespace facebook::react {
+
+extern const char TransformerTextInputDecoratorViewComponentName[];
+
+class TransformerTextInputDecoratorViewShadowNode final
+    : public ConcreteViewShadowNode<
+          TransformerTextInputDecoratorViewComponentName,
+          TransformerTextInputDecoratorViewProps,
+          TransformerTextInputDecoratorViewEventEmitter> {
+ public:
+  TransformerTextInputDecoratorViewShadowNode(
+      ShadowNodeFragment const &fragment,
+      ShadowNodeFamily::Shared const &family,
+      ShadowNodeTraits traits)
+      : ConcreteViewShadowNode(fragment, family, traits) {
+    initialize();
+  }
+
+  TransformerTextInputDecoratorViewShadowNode(
+      ShadowNode const &sourceShadowNode,
+      ShadowNodeFragment const &fragment)
+      : ConcreteViewShadowNode(sourceShadowNode, fragment) {
+    initialize();
+  }
+
+  void layout(LayoutContext layoutContext) override;
+
+ private:
+  void initialize();
+};
+
+} // namespace facebook::react

package/cpp/TransformerTextInputRuntime.cpp

@@ -0,0 +1,86 @@
+#include "TransformerTextInputRuntime.h"
+
+namespace rntti {
+
+namespace {
+std::shared_ptr<worklets::WorkletRuntime> gUiRuntime;
+} // namespace
+
+void SetUIWorkletRuntime(std::shared_ptr<worklets::WorkletRuntime> runtime) {
+  if (!runtime) {
+    gUiRuntime.reset();
+    return;
+  }
+  runtime->schedule([runtime]() { gUiRuntime = runtime; });
+}
+
+std::optional<jsi::WeakObject> LookupTransformer(int transformerId) {
+  auto uiRuntime = gUiRuntime;
+  if (!uiRuntime) {
+    return std::nullopt;
+  }
+  auto &runtime = uiRuntime->getJSIRuntime();
+  auto transformerRegistry = runtime.global().getPropertyAsObject(
+      runtime, "__rntti_registerTransformerRegistry");
+  auto transformerRegistryGet =
+      transformerRegistry.getPropertyAsFunction(runtime, "get");
+  auto transformerValue =
+      transformerRegistryGet.call(runtime, jsi::Value(transformerId));
+
+  if (transformerValue.isNull() || transformerValue.isUndefined() ||
+      !transformerValue.isObject()) {
+    return std::nullopt;
+  }
+
+  return jsi::WeakObject(runtime, transformerValue.asObject(runtime));
+}
+
+std::optional<TransformResult> RunTransformer(
+    const std::optional<jsi::WeakObject> &transformer,
+    const std::string &value,
+    SelectionRange selection) {
+  if (!transformer) {
+    return std::nullopt;
+  }
+
+  auto uiRuntime = gUiRuntime;
+  if (!uiRuntime) {
+    return std::nullopt;
+  }
+
+  auto &jsiRuntime = uiRuntime->getJSIRuntime();
+
+  auto transformerValue = transformer->lock(jsiRuntime);
+  if (transformerValue.isUndefined()) {
+    return std::nullopt;
+  }
+
+  auto transformerFunction =
+      transformerValue.asObject(jsiRuntime).asFunction(jsiRuntime);
+  auto resultValue = uiRuntime->runSync(
+      transformerFunction,
+      jsi::String::createFromUtf8(jsiRuntime, value),
+      jsi::Value(selection.start),
+      jsi::Value(selection.end));
+
+  TransformResult result;
+  auto resultObject = resultValue.asObject(jsiRuntime);
+  auto valueProp = resultObject.getProperty(jsiRuntime, "value");
+  if (valueProp.isString()) {
+    result.value = valueProp.asString(jsiRuntime).utf8(jsiRuntime);
+  }
+
+  auto selectionProp = resultObject.getProperty(jsiRuntime, "selection");
+  if (selectionProp.isObject()) {
+    auto selectionObject = selectionProp.asObject(jsiRuntime);
+    auto startProp = selectionObject.getProperty(jsiRuntime, "start");
+    auto endProp = selectionObject.getProperty(jsiRuntime, "end");
+    result.selection = SelectionRange{
+        static_cast<int>(startProp.asNumber()),
+        static_cast<int>(endProp.asNumber())};
+  }
+
+  return result;
+}
+
+} // namespace rntti

package/cpp/TransformerTextInputRuntime.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace rntti {
+
+struct SelectionRange {
+  int start{0};
+  int end{0};
+};
+
+struct TransformResult {
+  std::string value;
+  SelectionRange selection;
+};
+
+void SetUIWorkletRuntime(std::shared_ptr<worklets::WorkletRuntime> runtime);
+
+std::optional<jsi::WeakObject> LookupTransformer(int transformerId);
+
+std::optional<TransformResult> RunTransformer(
+    const std::optional<jsi::WeakObject> &transformer,
+    const std::string &value,
+    SelectionRange selection);
+
+} // namespace rntti

package/ios/TransformerTextInputDecoratorView.h

@@ -0,0 +1,9 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface TransformerTextInputDecoratorView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/TransformerTextInputDecoratorView.mm

@@ -0,0 +1,256 @@
+#import "TransformerTextInputDecoratorView.h"
+
+#import <React/RCTBackedTextInputDelegate.h>
+#import <React/RCTBackedTextInputViewProtocol.h>
+#import <React/RCTConversions.h>
+#import <React/RCTTextInputComponentView.h>
+#import <react/renderer/components/rntti/EventEmitters.h>
+#import <react/renderer/components/rntti/Props.h>
+#import <react/renderer/components/rntti/RCTComponentViewHelpers.h>
+#import "TransformerTextInputDecoratorViewComponentDescriptor.h"
+#import "TransformerTextInputRuntime.h"
+
+using namespace facebook::react;
+
+struct RNTTITextState {
+  NSString *value;
+  NSRange selection;
+};
+
+@interface TransformerTextInputDecoratorView () <
+    RCTTransformerTextInputDecoratorViewViewProtocol,
+    RCTBackedTextInputDelegate>
+
+@end
+
+@implementation TransformerTextInputDecoratorView {
+  std::optional<jsi::WeakObject> _transformer;
+  bool _observersAdded;
+  __weak id<RCTBackedTextInputDelegate> _baseDelegate;
+  __weak UIView<RCTBackedTextInputViewProtocol> *_backedTextInput;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<TransformerTextInputDecoratorViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = TransformerTextInputDecoratorViewShadowNode::defaultSharedProps();
+    _observersAdded = false;
+  }
+
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &oldViewProps = *std::static_pointer_cast<TransformerTextInputDecoratorViewProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<TransformerTextInputDecoratorViewProps const>(props);
+
+  if (oldViewProps.transformerId != newViewProps.transformerId) {
+    _transformer = rntti::LookupTransformer(newViewProps.transformerId);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)applyValue:(NSString *)newValue
+{
+  NSMutableAttributedString *newAttributedText =
+      [[NSMutableAttributedString alloc] initWithAttributedString:_backedTextInput.attributedText];
+
+  [newAttributedText replaceCharactersInRange:NSMakeRange(0, newAttributedText.length) withString:newValue];
+  _backedTextInput.attributedText = newAttributedText;
+}
+
+- (NSRange)currentSelection
+{
+  UITextRange *selectedTextRange = _backedTextInput.selectedTextRange;
+  if (!selectedTextRange) {
+    return NSMakeRange(0, 0);
+  }
+  NSInteger start = [_backedTextInput offsetFromPosition:_backedTextInput.beginningOfDocument
+                                              toPosition:selectedTextRange.start];
+  NSInteger end = [_backedTextInput offsetFromPosition:_backedTextInput.beginningOfDocument
+                                            toPosition:selectedTextRange.end];
+  return NSMakeRange(start, end - start);
+}
+
+- (NSString *)currentValue
+{
+  return _backedTextInput.attributedText.string ?: @"";
+}
+
+- (void)applySelection:(NSRange)selection
+{
+  UITextPosition *startPosition = [_backedTextInput positionFromPosition:_backedTextInput.beginningOfDocument
+                                                                  offset:selection.location];
+  UITextPosition *endPosition = [_backedTextInput positionFromPosition:_backedTextInput.beginningOfDocument
+                                                                offset:selection.location + selection.length];
+  if (!startPosition || !endPosition) {
+    return;
+  }
+  UITextRange *range = [_backedTextInput textRangeFromPosition:startPosition toPosition:endPosition];
+  if (range) {
+    [_backedTextInput setSelectedTextRange:range notifyDelegate:NO];
+  }
+}
+
+- (RNTTITextState)transformTextState:(RNTTITextState)state
+{
+  if (!_transformer) {
+    return state;
+  }
+
+  rntti::SelectionRange selectionRange{
+      static_cast<int>(state.selection.location), static_cast<int>(state.selection.location + state.selection.length)};
+  auto transformResult = rntti::RunTransformer(_transformer, RCTStringFromNSString(state.value), selectionRange);
+  if (!transformResult) {
+    return state;
+  }
+
+  NSString *value = RCTNSStringFromString(transformResult->value);
+  NSRange selection =
+      NSMakeRange(transformResult->selection.start, transformResult->selection.end - transformResult->selection.start);
+
+  return RNTTITextState{value, selection};
+}
+
+- (void)didAddSubview:(UIView *)subview
+{
+  [super didAddSubview:subview];
+
+  [self addTextInputObservers];
+}
+
+- (void)willRemoveSubview:(UIView *)subview
+{
+  [super willRemoveSubview:subview];
+
+  [self removeTextInputObservers];
+}
+
+- (void)addTextInputObservers
+{
+  react_native_assert(
+      !_observersAdded &&
+      "MarkdownTextInputDecoratorComponentView tried to add TextInput observers while they were attached");
+  react_native_assert(
+      self.subviews.count > 0 && "MarkdownTextInputDecoratorComponentView is mounted without any children");
+  UIView *childView = self.subviews[0];
+  react_native_assert(
+      [childView isKindOfClass:[RCTTextInputComponentView class]] &&
+      "Child component of MarkdownTextInputDecoratorComponentView is not an instance of RCTTextInputComponentView.");
+  RCTTextInputComponentView *textInputComponentView = (RCTTextInputComponentView *)childView;
+  UIView<RCTBackedTextInputViewProtocol> *backedTextInputView =
+      [textInputComponentView valueForKey:@"_backedTextInputView"];
+
+  _backedTextInput = backedTextInputView;
+  _baseDelegate = backedTextInputView.textInputDelegate;
+  backedTextInputView.textInputDelegate = self;
+
+  _observersAdded = true;
+}
+
+- (void)removeTextInputObservers
+{
+  _backedTextInput = nil;
+  _baseDelegate = nil;
+  _observersAdded = false;
+  _transformer = std::nullopt;
+}
+
+- (void)textInputDidBeginEditing
+{
+  [_baseDelegate textInputDidBeginEditing];
+}
+
+- (void)textInputDidChange
+{
+  // Current values
+  NSString *currentValue = [self currentValue];
+  NSRange currentSelection = [self currentSelection];
+  RNTTITextState current{currentValue, currentSelection};
+  RNTTITextState next = [self transformTextState:current];
+  bool didTransformValue = ![next.value isEqualToString:current.value];
+  if (didTransformValue) {
+    [self applyValue:next.value];
+  }
+  if (didTransformValue || !NSEqualRanges(next.selection, current.selection)) {
+    [self applySelection:next.selection];
+  }
+
+  [_baseDelegate textInputDidChange];
+}
+
+- (void)textInputDidChangeSelection
+{
+  [_baseDelegate textInputDidChangeSelection];
+}
+
+- (void)textInputDidEndEditing
+{
+  [_baseDelegate textInputDidEndEditing];
+}
+
+- (void)textInputDidReturn
+{
+  [_baseDelegate textInputDidReturn];
+}
+
+- (BOOL)textInputShouldBeginEditing
+{
+  return [_baseDelegate textInputShouldBeginEditing];
+}
+
+- (nonnull NSString *)textInputShouldChangeText:(nonnull NSString *)text inRange:(NSRange)range
+{
+  return [_baseDelegate textInputShouldChangeText:text inRange:range];
+}
+
+- (BOOL)textInputShouldEndEditing
+{
+  return [_baseDelegate textInputShouldEndEditing];
+}
+
+- (BOOL)textInputShouldReturn
+{
+  return [_baseDelegate textInputShouldReturn];
+}
+
+- (BOOL)textInputShouldSubmitOnReturn
+{
+  return [_baseDelegate textInputShouldSubmitOnReturn];
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTTransformerTextInputDecoratorViewHandleCommand(self, commandName, args);
+}
+
+- (void)update:(BOOL)transform
+             value:(NSString *)value
+    selectionStart:(NSInteger)selectionStart
+      selectionEnd:(NSInteger)selectionEnd
+{
+  NSString *currentValue = [self currentValue];
+  NSRange currentSelection = [self currentSelection];
+  NSString *providedValue = value ?: currentValue;
+  NSRange providedSelection = NSMakeRange(selectionStart, selectionEnd - selectionStart);
+  RNTTITextState provided{providedValue, providedSelection};
+  RNTTITextState next = transform ? [self transformTextState:provided] : provided;
+  bool didTransformValue = ![next.value isEqualToString:currentValue];
+  if (didTransformValue) {
+    [self applyValue:next.value];
+  }
+  if (didTransformValue || !NSEqualRanges(next.selection, currentSelection)) {
+    [self applySelection:next.selection];
+  }
+
+  [_baseDelegate textInputDidChange];
+}
+
+@end

package/ios/TransformerTextInputModule.h

@@ -0,0 +1,8 @@
+#import <ReactCodegen/rntti/rntti.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface TransformerTextInputModule : NativeTransformerTextInputModuleSpecBase <NativeTransformerTextInputModuleSpec>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/TransformerTextInputModule.mm

@@ -0,0 +1,28 @@
+#import "TransformerTextInputModule.h"
+
+#import <jsi/jsi.h>
+#import <rnworklets/worklets/apple/WorkletsModule.h>
+
+#import "TransformerTextInputRuntime.h"
+
+@implementation TransformerTextInputModule
+
+RCT_EXPORT_MODULE(TransformerTextInputModule)
+
+@synthesize moduleRegistry = _moduleRegistry;
+
+- (NSNumber *)install
+{
+  WorkletsModule *workletsModule = [_moduleRegistry moduleForName:"WorkletsModule"];
+  auto uiRuntime = [workletsModule getWorkletsModuleProxy]->getUIWorkletRuntime();
+  rntti::SetUIWorkletRuntime(uiRuntime);
+  return @YES;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeTransformerTextInputModuleSpecJSI>(params);
+}
+
+@end

package/lib/module/NativeTransformerTextInputModule.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('TransformerTextInputModule');
+//# sourceMappingURL=NativeTransformerTextInputModule.js.map

package/lib/module/NativeTransformerTextInputModule.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeTransformerTextInputModule.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;AAMlD,eAAeA,mBAAmB,CAACC,YAAY,CAC7C,4BACF,CAAC","ignoreList":[]}