@amazon-devices/react-native-worklets 1.0.0-rn-83

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntime.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <jsi/jsi.h>
+#include <jsireact/JSIExecutor.h>
+#include <react/debug/react_native_assert.h>
+
+#include <worklets/Public/AsyncQueue.h>
+#include <worklets/RunLoop/AsyncQueueImpl.h>
+#include <worklets/RunLoop/EventLoop.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+using namespace facebook;
+using namespace react;
+
+namespace worklets {
+
+/**
+ * Forward declaration to avoid circular dependencies.
+ */
+class JSIWorkletsModuleProxy;
+
+class WorkletRuntime : public jsi::HostObject,
+                       public std::enable_shared_from_this<WorkletRuntime> {
+ public:
+  explicit WorkletRuntime(
+      uint64_t runtimeId,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::string &name,
+      const std::shared_ptr<AsyncQueue> &queue = nullptr,
+      bool enableEventLoop = true);
+
+  void init(std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsModuleProxy);
+
+  facebook::jsi::Runtime &getJSIRuntime() const {
+    return *runtime_;
+  }
+
+  template <typename... Args>
+  inline jsi::Value runGuarded(
+      const std::shared_ptr<SerializableWorklet> &serializableWorklet,
+      Args &&...args) const {
+    jsi::Runtime &rt = *runtime_;
+    return runOnRuntimeGuarded(
+        rt, serializableWorklet->toJSValue(rt), std::forward<Args>(args)...);
+  }
+
+  void runAsyncGuarded(const std::shared_ptr<SerializableWorklet> &worklet);
+
+  jsi::Value executeSync(facebook::jsi::Runtime &rt, const facebook::jsi::Value &worklet) const;
+
+#ifdef WORKLETS_BUNDLE_MODE
+  jsi::Value executeSync(std::function<jsi::Value(jsi::Runtime &)> &&job) const;
+
+  jsi::Value executeSync(
+      const std::function<jsi::Value(jsi::Runtime &)> &job) const;
+#endif // WORKLETS_BUNDLE_MODE
+
+  std::string toString() const {
+    return "[WorkletRuntime \"" + name_ + "\"]";
+  }
+
+  jsi::Value get(facebook::jsi::Runtime &rt, const facebook::jsi::PropNameID &propName) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  [[nodiscard]] auto getRuntimeId() const -> uint64_t {
+    return runtimeId_;
+  }
+
+  [[nodiscard]] auto getRuntimeName() const -> std::string {
+    return name_;
+  }
+
+ private:
+  const uint64_t runtimeId_;
+  const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
+  const std::shared_ptr<jsi::Runtime> runtime_;
+  const std::string name_;
+  std::shared_ptr<AsyncQueue> queue_;
+  std::shared_ptr<EventLoop> eventLoop_;
+};
+
+// This function needs to be non-inline to avoid problems with dynamic_cast on
+// Android
+std::shared_ptr<WorkletRuntime> extractWorkletRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &value);
+
+void scheduleOnRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &workletRuntimeValue,
+    const jsi::Value &serializableWorkletValue);
+
+} // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeCollector.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace worklets {
+
+class WorkletRuntimeCollector : public jsi::HostObject {
+  // When worklet runtime is created, we inject an instance of this class as a
+  // `jsi::HostObject` into the global object. When worklet runtime is
+  // terminated, the object is garbage-collected, which runs the C++ destructor.
+  // In the destructor, we unregister the worklet runtime from the registry.
+
+ public:
+  explicit WorkletRuntimeCollector(jsi::Runtime &runtime) : runtime_(runtime) {
+    WorkletRuntimeRegistry::registerRuntime(runtime_);
+  }
+
+  ~WorkletRuntimeCollector() {
+    WorkletRuntimeRegistry::unregisterRuntime(runtime_);
+  }
+
+  static void install(jsi::Runtime &rt) {
+    auto collector = std::make_shared<WorkletRuntimeCollector>(rt);
+    auto object = jsi::Object::createFromHostObject(rt, collector);
+    rt.global().setProperty(rt, "__workletRuntimeCollector", object);
+  }
+
+ private:
+  jsi::Runtime &runtime_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeDecorator.cpp

@@ -0,0 +1,308 @@
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/Tools/JSISerializer.h>
+#include <worklets/Tools/PlatformLogger.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
+#include <worklets/WorkletRuntime/RuntimeKind.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
+
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+static inline double performanceNow() {
+  // copied from JSExecutor.cpp
+  auto time = std::chrono::steady_clock::now();
+  auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                      time.time_since_epoch())
+                      .count();
+
+  constexpr double NANOSECONDS_IN_MILLISECOND = 1000000.0;
+  return duration / NANOSECONDS_IN_MILLISECOND;
+}
+
+static inline std::vector<jsi::Value> parseArgs(
+    jsi::Runtime &rt,
+    std::shared_ptr<SerializableArray> serializableArgs) {
+  if (serializableArgs == nullptr) {
+    return {};
+  }
+
+  auto argsArray = serializableArgs->toJSValue(rt).asObject(rt).asArray(rt);
+  auto argsSize = argsArray.size(rt);
+  std::vector<jsi::Value> result(argsSize);
+  for (size_t i = 0; i < argsSize; i++) {
+    result[i] = argsArray.getValueAtIndex(rt, i);
+  }
+  return result;
+}
+
+void WorkletRuntimeDecorator::decorate(
+    jsi::Runtime &rt,
+    const std::string &name,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const bool isDevBundle,
+    jsi::Object &&jsiWorkletsModuleProxy,
+    const std::shared_ptr<EventLoop> &eventLoop) {
+  // resolves "ReferenceError: Property 'global' doesn't exist at ..."
+  rt.global().setProperty(rt, "global", rt.global());
+
+  rt.global().setProperty(
+      rt, runtimeKindBindingName, static_cast<int>(RuntimeKind::Worker));
+
+  rt.global().setProperty(rt, "_WORKLET", true);
+
+  rt.global().setProperty(rt, "_LABEL", jsi::String::createFromAscii(rt, name));
+
+  // TODO: Remove _IS_FABRIC sometime in the future
+  // react-native-screens 4.9.0 depends on it
+  rt.global().setProperty(rt, "_IS_FABRIC", true);
+
+  rt.global().setProperty(rt, "__DEV__", isDevBundle);
+
+  rt.global().setProperty(
+      rt, "__workletsModuleProxy", std::move(jsiWorkletsModuleProxy));
+
+#ifndef NDEBUG
+  auto evalWithSourceUrl = [](jsi::Runtime &rt,
+                              const jsi::Value &thisValue,
+                              const jsi::Value *args,
+                              size_t count) -> jsi::Value {
+    auto code = std::make_shared<const jsi::StringBuffer>(
+        args[0].asString(rt).utf8(rt));
+    std::string url;
+    if (count > 1 && args[1].isString()) {
+      url = args[1].asString(rt).utf8(rt);
+    }
+    return rt.evaluateJavaScript(code, url);
+  };
+  rt.global().setProperty(
+      rt,
+      "evalWithSourceUrl",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "evalWithSourceUrl"),
+          1,
+          evalWithSourceUrl));
+#endif // NDEBUG
+
+  jsi_utils::installJsiFunction(
+      rt, "_log", [](jsi::Runtime &rt, const jsi::Value &value) {
+        PlatformLogger::log(stringifyJSIValue(rt, value));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt, "_toString", [](jsi::Runtime &rt, const jsi::Value &value) {
+        return jsi::String::createFromUtf8(rt, stringifyJSIValue(rt, value));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializable",
+      [](jsi::Runtime &rt,
+         const jsi::Value &value,
+         const jsi::Value &nativeStateSource) {
+        auto shouldRetainRemote = jsi::Value::undefined();
+        return makeSerializableClone(
+            rt, value, shouldRetainRemote, nativeStateSource);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableHostObject",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeSerializableHostObject(
+            rt, value.asObject(rt).asHostObject(rt));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableString",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeSerializableString(rt, value.asString(rt));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableNumber",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeSerializableNumber(rt, value.asNumber());
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableBoolean",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeSerializableBoolean(rt, value.asBool());
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableBigInt",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeSerializableBigInt(rt, value.asBigInt(rt));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt, "_createSerializableUndefined", [](jsi::Runtime &rt) {
+        return makeSerializableUndefined(rt);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableArray",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeSerializableArray(rt, value.asObject(rt).asArray(rt), false);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt, "_createSerializableNull", [](jsi::Runtime &rt) {
+        return makeSerializableNull(rt);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableObject",
+      [](jsi::Runtime &rt,
+         const jsi::Value &value,
+         const jsi::Value &shouldRetainRemote,
+         const jsi::Value &nativeStateSource) {
+        return makeSerializableObject(
+            rt,
+            value.getObject(rt),
+            shouldRetainRemote.getBool(),
+            nativeStateSource);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableWorklet",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeSerializableWorklet(rt, value.asObject(rt), false);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableInitializer",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeSerializableInitializer(rt, value.asObject(rt));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableFunction",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeSerializableFunction(rt, value.asObject(rt).asFunction(rt));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableSynchronizable",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return SerializableJSRef::newNativeStateObject(
+            rt, extractSerializableOrThrow(rt, value));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleRemoteFunctionOnJS",
+      [jsScheduler](
+          jsi::Runtime &rt,
+          const jsi::Value &funValue,
+          const jsi::Value &argsValue) {
+        auto serializableRemoteFun = extractSerializableOrThrow<
+            SerializableRemoteFunction>(
+            rt,
+            funValue,
+            "[Worklets] Incompatible object passed to scheduleOnJS. It is only allowed to schedule worklets or functions defined on the React Native JS runtime this way.");
+
+        auto serializableArgs = argsValue.isUndefined()
+            ? nullptr
+            : extractSerializableOrThrow<SerializableArray>(
+                  rt, argsValue, "[Worklets] Args must be an array.");
+
+        jsScheduler->scheduleOnJS([=](jsi::Runtime &rt) {
+          auto fun =
+              serializableRemoteFun->toJSValue(rt).asObject(rt).asFunction(rt);
+          if (serializableArgs == nullptr) {
+            // fast path for remote function w/o arguments
+            fun.call(rt);
+          } else {
+            auto args = parseArgs(rt, serializableArgs);
+            fun.call(
+                rt, const_cast<const jsi::Value *>(args.data()), args.size());
+          }
+        });
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleHostFunctionOnJS",
+      [jsScheduler](
+          jsi::Runtime &rt,
+          const jsi::Value &hostFunValue,
+          const jsi::Value &argsValue) {
+        auto hostFun =
+            hostFunValue.asObject(rt).asFunction(rt).getHostFunction(rt);
+
+        auto serializableArgs = argsValue.isUndefined()
+            ? nullptr
+            : extractSerializableOrThrow<SerializableArray>(
+                  rt, argsValue, "[Worklets] Args must be an array.");
+
+        jsScheduler->scheduleOnJS([=](jsi::Runtime &rt) {
+          auto args = parseArgs(rt, serializableArgs);
+          hostFun(
+              rt,
+              jsi::Value::undefined(),
+              const_cast<const jsi::Value *>(args.data()),
+              args.size());
+        });
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleOnRuntime",
+      [](jsi::Runtime &rt,
+         const jsi::Value &workletRuntimeValue,
+         const jsi::Value &serializableWorkletValue) {
+        scheduleOnRuntime(rt, workletRuntimeValue, serializableWorkletValue);
+      });
+
+  jsi::Object performance(rt);
+  performance.setProperty(
+      rt,
+      "now",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "now"),
+          0,
+          [](jsi::Runtime &runtime,
+             const jsi::Value &,
+             const jsi::Value *args,
+             size_t count) { return jsi::Value(performanceNow()); }));
+  rt.global().setProperty(rt, "performance", performance);
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleTimeoutCallback",
+      [weakEventLoop = std::weak_ptr<EventLoop>(eventLoop)](
+          jsi::Runtime &rt,
+          const jsi::Value &delayJs,
+          const jsi::Value &handlerIdJs) -> jsi::Value {
+        const auto delay = delayJs.asNumber();
+        const auto handlerId = handlerIdJs.asNumber();
+        const auto job = [handlerId](jsi::Runtime &rt) {
+          rt.global()
+              .getPropertyAsFunction(rt, "__runTimeoutCallback")
+              .call(rt, handlerId);
+        };
+        if (auto strongEventLoop = weakEventLoop.lock()) {
+          strongEventLoop->pushTimeout(job, delay);
+        }
+        return jsi::Value::undefined();
+      });
+}
+
+} // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeDecorator.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <worklets/RunLoop/EventLoop.h>
+#include <worklets/Tools/JSScheduler.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntimeDecorator {
+ public:
+  static void decorate(
+      jsi::Runtime &rt,
+      const std::string &name,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const bool isDevBundle,
+      jsi::Object &&jsiWorkletsModuleProxy,
+      const std::shared_ptr<EventLoop> &eventLoop);
+};
+
+} // namespace worklets

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Amazon.com, Inc. or its affiliates.  All rights reserved.
+
+These materials are licensed as "Program Materials" under the Program Materials License Agreement (the "Agreement").  The Agreement is available at https://developer.amazon.com/support/legal/pml.  See the Agreement for the specific terms and conditions of the Agreement.  Capitalized terms not defined in this file have the meanings given to them in the Agreement.  
+
+If you do not agree to the above terms and conditions, you may not use any file in this package. 
+
+YOUR USE OF THE PROGRAM MATERIALS IN OR ASSOCIATED WITH THIS PACKAGE IS AT YOUR SOLE RISK.  IN NO EVENT WILL AMAZON BE LIABLE FOR ANY DAMAGES, INCLUDING WITHOUT LIMITATION ANY DIRECT, INDIRECT, CONSEQUENTIAL, SPECIAL, INCIDENTAL, OR PUNITIVE DAMAGES (INCLUDING FOR ANY LOSS OF GOODWILL, BUSINESS INTERRUPTION, LOST PROFITS OR DATA, OR COMPUTER FAILURE OR MALFUNCTION) ARISING FROM OR RELATING TO SUCH PROGRAM MATERIALS, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, EVEN IF AMAZON HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS AND DISCLAIMERS APPLY EXCEPT TO THE EXTENT PROHIBITED BY APPLICABLE LAW.

package/README.md

@@ -0,0 +1,31 @@
+![header](https://github.com/user-attachments/assets/41b37472-e55a-4c54-9064-31258e03870c)
+
+### The React Native multithreading library
+
+React Native Worklets is a library that allows you to run JavaScript code in parallel on multiple threads and runtimes.
+
+While the library is in transitional period where we hone the API, all its features are functionally stable and ready to use in production.
+
+## Documentation
+
+Check out our dedicated documentation page for info about this library, API reference and more: [https://docs.swmansion.com/react-native-worklets/](https://docs.swmansion.com/react-native-worklets/)
+
+## License
+
+Worklets library is licensed under [The MIT License](LICENSE).
+
+## Credits
+
+This project has been built and is maintained thanks to the support from [Shopify](https://shopify.com), [Expo.io](https://expo.io) and [Software Mansion](https://swmansion.com)
+
+[![shopify](https://avatars1.githubusercontent.com/u/8085?v=3&s=100 'Shopify.com')](https://shopify.com)
+[![expo](https://avatars2.githubusercontent.com/u/12504344?v=3&s=100 'Expo.io')](https://expo.io)
+[![swm](https://logo.swmansion.com/logo?color=white&variant=desktop&width=150&tag=react-native-reanimated-github 'Software Mansion')](https://swmansion.com)
+
+## Community Discord
+
+[Join the Software Mansion Community Discord](https://discord.swmansion.com) to chat about Worklets or other Software Mansion libraries.
+
+## Worklets are created by Software Mansion
+
+Since 2012 [Software Mansion](https://swmansion.com) is a software agency with experience in building web and mobile apps. We are Core React Native Contributors and experts in dealing with all kinds of React Native issues. We can help you build your next dream product – [Hire us](https://swmansion.com/contact/projects?utm_source=reanimated&utm_medium=readme).

package/RNWorklets.podspec

@@ -0,0 +1,94 @@
+require "json"
+require_relative './scripts/worklets_utils'
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+$worklets_config = worklets_find_config()
+worklets_assert_minimal_react_native_version($worklets_config)
+
+$new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] != '0'
+worklets_assert_new_architecture_enabled($new_arch_enabled)
+
+ios_min_version = '13.4'
+
+feature_flags = "-DWORKLETS_FEATURE_FLAGS=\"#{worklets_get_static_feature_flags()}\""
+version_flags = "-DWORKLETS_VERSION=#{package['version']}"
+
+Pod::Spec.new do |s|
+  s.name         = "RNWorklets"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://github.com/software-mansion/react-native-reanimated"
+  s.license      = package["license"]
+  s.authors      = { "author" => "author@domain.com" }
+  s.platforms    = { :ios => ios_min_version, :tvos => "9.0", :osx => "10.14", :visionos => "1.0" }
+  s.source       = { :git => "https://github.com/software-mansion/react-native-reanimated.git", :tag => "#{s.version}" }
+
+  s.subspec "worklets" do |ss|
+    ss.source_files = "Common/cpp/worklets/**/*.{cpp,h}"
+    ss.header_dir = "worklets"
+    ss.header_mappings_dir = "Common/cpp/worklets"
+
+    ss.subspec "apple" do |sss|
+      # Please be careful with the snakes.
+      # 🐍🐍🐍
+      # Thank you for your understanding.
+      sss.source_files = "apple/worklets/**/*.{mm,h,m}"
+      sss.header_dir = "worklets"
+      sss.header_mappings_dir = "apple/worklets"
+    end
+  end
+
+  # Use install_modules_dependencies helper to install the dependencies.
+  # See https://github.com/facebook/react-native/blob/c925872e72d2422be46670777bfa2111e13c9e4c/packages/react-native/scripts/cocoapods/new_architecture.rb#L71.
+  install_modules_dependencies(s)
+
+  s.dependency 'React-jsi'
+  using_hermes = ENV['USE_HERMES'] == nil || ENV['USE_HERMES'] == '1'
+  if using_hermes && !$worklets_config[:is_tvos_target]
+    s.dependency 'React-hermes'
+  end
+
+  # React Native doesn't expose these flags, but not having them
+  # can lead to runtime errors due to ABI mismatches.
+  # There's also
+  #   HERMESVM_PROFILER_OPCODE
+  #   HERMESVM_PROFILER_BB
+  # which shouldn't be defined in standard setups.
+  hermes_debug_hidden_flags = 'HERMES_ENABLE_DEBUGGER=1'
+
+  bundle_mode_flag = $worklets_config[:bundle_mode] ? 'WORKLETS_BUNDLE_MODE=1' : ''
+  
+  s.pod_target_xcconfig = {
+    "USE_HEADERMAP" => "YES",
+    "DEFINES_MODULE" => "YES",
+    "HEADER_SEARCH_PATHS" => [
+      '"$(PODS_TARGET_SRCROOT)/ReactCommon"',
+      '"$(PODS_TARGET_SRCROOT)"',
+      '"$(PODS_ROOT)/RCT-Folly"',
+      '"$(PODS_ROOT)/boost"',
+      '"$(PODS_ROOT)/boost-for-react-native"',
+      '"$(PODS_ROOT)/DoubleConversion"',
+      '"$(PODS_ROOT)/Headers/Private/React-Core"',
+      '"$(PODS_ROOT)/Headers/Private/Yoga"',
+    ].join(' '),
+    "FRAMEWORK_SEARCH_PATHS" => '"${PODS_CONFIGURATION_BUILD_DIR}/React-hermes"',
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "GCC_PREPROCESSOR_DEFINITIONS[config=*Debug*]" => "$(inherited) #{hermes_debug_hidden_flags} #{bundle_mode_flag}",
+    "GCC_PREPROCESSOR_DEFINITIONS[config=*Release*]" => "$(inherited) #{bundle_mode_flag}",
+    "OTHER_CFLAGS" => "$(inherited) #{feature_flags} #{version_flags}",
+  }
+  s.xcconfig = {
+    "HEADER_SEARCH_PATHS" => [
+      '"$(PODS_ROOT)/boost"',
+      '"$(PODS_ROOT)/boost-for-react-native"',
+      '"$(PODS_ROOT)/glog"',
+      '"$(PODS_ROOT)/RCT-Folly"',
+      '"$(PODS_ROOT)/Headers/Public/React-hermes"',
+      '"$(PODS_ROOT)/Headers/Public/hermes-engine"',
+      "\"$(PODS_ROOT)/#{$worklets_config[:react_native_common_dir]}\"",
+      "\"$(PODS_ROOT)/#{$worklets_config[:dynamic_frameworks_worklets_dir]}/apple\"",
+      "\"$(PODS_ROOT)/#{$worklets_config[:dynamic_frameworks_worklets_dir]}/Common/cpp\"",
+    ].join(' '),
+  }
+  
+end