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

package/apple/worklets/apple/WorkletsDisplayLink.h

@@ -0,0 +1,21 @@
+#if TARGET_OS_OSX
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#import <React/RCTPlatformDisplayLink.h>
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+typedef RCTPlatformDisplayLink WorkletsDisplayLink;
+
+#else // TARGET_OS_OSX
+
+#import <QuartzCore/CADisplayLink.h>
+
+typedef CADisplayLink WorkletsDisplayLink;
+
+#endif // TARGET_OS_OSX

package/apple/worklets/apple/WorkletsMessageThread.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <React/RCTMessageThread.h>
+
+namespace facebook {
+namespace react {
+
+class WorkletsMessageThread : public RCTMessageThread {
+ public:
+  using RCTMessageThread::RCTMessageThread;
+  virtual void quitSynchronous() override;
+};
+
+} // namespace react
+} // namespace facebook

package/apple/worklets/apple/WorkletsMessageThread.mm

@@ -0,0 +1,31 @@
+#import <worklets/apple/AssertJavaScriptQueue.h>
+#import <worklets/apple/WorkletsMessageThread.h>
+
+namespace facebook {
+namespace react {
+
+// Essentially the same as RCTMessageThread, but with public fields.
+struct WorkletsMessageThreadPublic {
+  // I don't know why we need three vtables (if you know then feel free to explain it instead of this message),
+  // but this is what makes the casts in quitSynchronous() work correctly.
+  void *vtable1;
+  void *vtable2;
+  void *vtable3;
+  CFRunLoopRef m_cfRunLoop;
+  RCTJavaScriptCompleteBlock m_errorBlock;
+  std::atomic_bool m_shutdown;
+};
+
+// We need to prevent any new code from being executed on the thread as there
+// is an assertion for that in the destructor of RCTMessageThread, but we have
+// to override quitSynchronous() as it would quit the main looper and freeze
+// the app.
+void WorkletsMessageThread::quitSynchronous()
+{
+  RCTMessageThread *rctThread = static_cast<RCTMessageThread *>(this);
+  WorkletsMessageThreadPublic *rctThreadPublic = reinterpret_cast<WorkletsMessageThreadPublic *>(rctThread);
+  rctThreadPublic->m_shutdown = true;
+}
+
+} // namespace react
+} // namespace facebook

package/apple/worklets/apple/WorkletsModule.h

@@ -0,0 +1,28 @@
+#import <React/RCTCallInvokerModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTInvalidating.h>
+
+#import <rnworklets/rnworklets.h>
+
+#import <worklets/NativeModules/WorkletsModuleProxy.h>
+
+#if __has_include(<React/RCTBundleConsumer.h>)
+// Bundle mode
+#import <React/NSBigStringBuffer.h>
+#import <React/RCTBundleConsumer.h>
+#endif // __has_include(<React/RCTBundleConsumer.h>)
+
+@interface WorkletsModule : RCTEventEmitter <
+                                NativeWorkletsModuleSpec,
+                                RCTCallInvokerModule,
+                                RCTInvalidating
+#if __has_include(<React/RCTBundleConsumer.h>)
+                                // Bundle mode
+                                ,
+                                RCTBundleConsumer
+#endif // __has_include(<React/RCTBundleConsumer.h>)
+                                >
+
+- (std::shared_ptr<worklets::WorkletsModuleProxy>)getWorkletsModuleProxy;
+
+@end

package/apple/worklets/apple/WorkletsModule.mm

@@ -0,0 +1,121 @@
+#import <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#import <worklets/Tools/SingleInstanceChecker.h>
+#import <worklets/Tools/WorkletsJSIUtils.h>
+#import <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+#import <worklets/apple/AnimationFrameQueue.h>
+#import <worklets/apple/AssertJavaScriptQueue.h>
+#import <worklets/apple/AssertTurboModuleManagerQueue.h>
+#import <worklets/apple/IOSUIScheduler.h>
+#import <worklets/apple/WorkletsMessageThread.h>
+#import <worklets/apple/WorkletsModule.h>
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTCallInvoker.h>
+
+using worklets::RNRuntimeWorkletDecorator;
+using worklets::WorkletsModuleProxy;
+
+@interface RCTBridge (JSIRuntime)
+- (void *)runtime;
+@end
+
+@implementation WorkletsModule {
+  AnimationFrameQueue *animationFrameQueue_;
+  std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy_;
+#ifndef NDEBUG
+  worklets::SingleInstanceChecker<WorkletsModule> singleInstanceChecker_;
+#endif // NDEBUG
+}
+
+- (std::shared_ptr<WorkletsModuleProxy>)getWorkletsModuleProxy
+{
+  AssertJavaScriptQueue();
+  return workletsModuleProxy_;
+}
+
+#if __has_include(<React/RCTBundleConsumer.h>)
+// Bundle mode
+@synthesize scriptBuffer = scriptBuffer_;
+@synthesize sourceURL = sourceURL_;
+#endif // __has_include(<React/RCTBundleConsumer.h>)
+
+- (void)checkBridgeless
+{
+  auto isBridgeless = ![self.bridge isKindOfClass:[RCTCxxBridge class]];
+  react_native_assert(isBridgeless && "[Worklets] react-native-worklets only supports bridgeless mode");
+}
+
+@synthesize callInvoker = _callInvoker;
+
+RCT_EXPORT_MODULE(WorkletsModule);
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(installTurboModule)
+{
+  react_native_assert(self.bridge != nullptr);
+  [self checkBridgeless];
+  react_native_assert(self.bridge.runtime != nullptr);
+
+  AssertJavaScriptQueue();
+
+  jsi::Runtime &rnRuntime = *reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
+
+  auto jsQueue = std::make_shared<WorkletsMessageThread>([NSRunLoop currentRunLoop], ^(NSError *error) {
+    throw error;
+  });
+
+  std::string sourceURL = "";
+  std::shared_ptr<const BigStringBuffer> script = nullptr;
+#ifdef WORKLETS_BUNDLE_MODE
+  script = [scriptBuffer_ getBuffer];
+  sourceURL = [sourceURL_ UTF8String];
+#endif // WORKLETS_BUNDLE_MODE
+
+  auto jsCallInvoker = _callInvoker.callInvoker;
+  auto uiScheduler = std::make_shared<worklets::IOSUIScheduler>();
+  auto isJavaScriptQueue = []() -> bool { return IsJavaScriptQueue(); };
+  animationFrameQueue_ = [AnimationFrameQueue new];
+  auto forwardedRequestAnimationFrame = std::function<void(std::function<void(const double)>)>(
+      [animationFrameQueue = animationFrameQueue_](std::function<void(const double)> callback) {
+        [animationFrameQueue requestAnimationFrame:callback];
+      });
+  workletsModuleProxy_ = std::make_shared<WorkletsModuleProxy>(
+      rnRuntime,
+      jsQueue,
+      jsCallInvoker,
+      uiScheduler,
+      std::move(isJavaScriptQueue),
+      std::move(forwardedRequestAnimationFrame),
+      script,
+      sourceURL);
+  auto jsiWorkletsModuleProxy = workletsModuleProxy_->createJSIWorkletsModuleProxy();
+  auto optimizedJsiWorkletsModuleProxy = worklets::jsi_utils::optimizedFromHostObject(
+      rnRuntime, std::static_pointer_cast<jsi::HostObject>(std::move(jsiWorkletsModuleProxy)));
+  RNRuntimeWorkletDecorator::decorate(
+      rnRuntime, std::move(optimizedJsiWorkletsModuleProxy), workletsModuleProxy_->getJSLogger());
+
+  return @YES;
+}
+
+- (void)invalidate
+{
+  AssertTurboModuleManagerQueue();
+
+  [animationFrameQueue_ invalidate];
+
+  // We have to destroy extra runtimes when invalidate is called. If we clean
+  // it up later instead there's a chance the runtime will retain references
+  // to invalidated memory and will crash on destruction.
+  workletsModuleProxy_.reset();
+
+  [super invalidate];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  [self checkBridgeless];
+  AssertJavaScriptQueue();
+  return std::make_shared<facebook::react::NativeWorkletsModuleSpecJSI>(params);
+}
+
+@end

package/bundleMode/index.d.ts

@@ -0,0 +1,3 @@
+declare module 'react-native-worklets/bundleMode' {
+  export const bundleModeMetroConfig: any;
+}

package/bundleMode/index.js

@@ -0,0 +1,59 @@
+const { getDefaultConfig } = require('@react-native/metro-config');
+const path = require('path');
+
+const workletsPackageParentDir = path.resolve(__dirname, '../..');
+
+const defaults = getDefaultConfig(__dirname);
+
+module.exports = {
+  bundleModeMetroConfig: {
+    serializer: {
+      getModulesRunBeforeMainModule(/** @type {string} dirname */ dirname) {
+        return [
+          require.resolve('react-native-worklets/src/workletRuntimeEntry.ts'),
+          require.resolve(
+            'react-native-worklets/lib/module/workletRuntimeEntry.js'
+          ),
+          ...defaults.serializer.getModulesRunBeforeMainModule(dirname),
+        ];
+      },
+      createModuleIdFactory() {
+        let nextId = 0;
+        const idFileMap = new Map();
+        return (/** @type {string} */ moduleName) => {
+          if (idFileMap.has(moduleName)) {
+            return idFileMap.get(moduleName);
+          }
+          if (
+            moduleName.includes('react-native-worklets/__generatedWorklets/')
+          ) {
+            const base = path.basename(moduleName, '.js');
+            const id = Number(base);
+            idFileMap.set(moduleName, id);
+            return id;
+          }
+          idFileMap.set(moduleName, nextId++);
+          return idFileMap.get(moduleName);
+        };
+      },
+    },
+    resolver: {
+      resolveRequest: (
+        /** @type {any} */ context,
+        /** @type {string} */ moduleName,
+        /** @type {any} */ platform
+      ) => {
+        if (
+          moduleName.startsWith('react-native-worklets/__generatedWorklets/')
+        ) {
+          const fullModuleName = path.join(
+            workletsPackageParentDir,
+            moduleName
+          );
+          return { type: 'sourceFile', filePath: fullModuleName };
+        }
+        return context.resolveRequest(context, moduleName, platform);
+      },
+    },
+  },
+};

package/compatibility.json

@@ -0,0 +1,11 @@
+{
+  "nightly": {
+    "react-native": ["0.78", "0.79", "0.80", "0.81"]
+  },
+  "0.5.x": {
+    "react-native": ["0.78", "0.79", "0.80", "0.81"]
+  },
+  "0.4.x": {
+    "react-native": ["0.78", "0.79", "0.80", "0.81"]
+  }
+}

package/kepler-compatibility.json

@@ -0,0 +1,5 @@
+{
+  "versions": {
+    "1.0.0": "/com.amazon.kepler.worklets_1@IWorklets_0"
+  }
+}

package/kepler-transformed-package-info.json

@@ -0,0 +1,3 @@
+{
+  "sourcePackageRef": "@amzn/react-native-worklets"
+}

package/lib/module/PlatformChecker/PlatformChecker.js

@@ -0,0 +1,8 @@
+'use strict';
+
+import { Platform } from 'react-native';
+export const IS_JEST = !!process.env.JEST_WORKER_ID;
+export const IS_WEB = Platform.OS === 'web';
+export const IS_WINDOWS = Platform.OS === 'windows';
+export const SHOULD_BE_USE_WEB = IS_JEST || IS_WEB || IS_WINDOWS;
+//# sourceMappingURL=PlatformChecker.js.map

package/lib/module/PlatformChecker/PlatformChecker.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Platform","IS_JEST","process","env","JEST_WORKER_ID","IS_WEB","OS","IS_WINDOWS","SHOULD_BE_USE_WEB"],"sourceRoot":"../../../src","sources":["PlatformChecker/PlatformChecker.ts"],"mappings":"AAAA,YAAY;;AACZ,SAASA,QAAQ,QAAQ,cAAc;AAEvC,OAAO,MAAMC,OAAgB,GAAG,CAAC,CAACC,OAAO,CAACC,GAAG,CAACC,cAAc;AAC5D,OAAO,MAAMC,MAAe,GAAGL,QAAQ,CAACM,EAAE,KAAK,KAAK;AACpD,OAAO,MAAMC,UAAmB,GAAGP,QAAQ,CAACM,EAAE,KAAK,SAAS;AAC5D,OAAO,MAAME,iBAA0B,GAAGP,OAAO,IAAII,MAAM,IAAIE,UAAU","ignoreList":[]}

package/lib/module/PlatformChecker/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+import { RuntimeKind } from '../runtimeKind';
+import { IS_JEST as RN_IS_JEST, IS_WEB as RN_IS_WEB, IS_WINDOWS as RN_IS_WINDOWS, SHOULD_BE_USE_WEB as RN_SHOULD_BE_USE_WEB } from './PlatformChecker';
+let IS_JEST = false;
+let IS_WEB = false;
+let IS_WINDOWS = false;
+let SHOULD_BE_USE_WEB = false;
+if (globalThis.__RUNTIME_KIND === RuntimeKind.ReactNative) {
+  IS_JEST = RN_IS_JEST;
+  IS_WEB = RN_IS_WEB;
+  IS_WINDOWS = RN_IS_WINDOWS;
+  SHOULD_BE_USE_WEB = RN_SHOULD_BE_USE_WEB;
+}
+export { IS_JEST, /** @knipIgnore */
+IS_WEB, /** @knipIgnore */
+IS_WINDOWS, SHOULD_BE_USE_WEB };
+//# sourceMappingURL=index.js.map

package/lib/module/PlatformChecker/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RuntimeKind","IS_JEST","RN_IS_JEST","IS_WEB","RN_IS_WEB","IS_WINDOWS","RN_IS_WINDOWS","SHOULD_BE_USE_WEB","RN_SHOULD_BE_USE_WEB","globalThis","__RUNTIME_KIND","ReactNative"],"sourceRoot":"../../../src","sources":["PlatformChecker/index.ts"],"mappings":"AAAA,YAAY;;AAEZ,SAASA,WAAW,QAAQ,gBAAgB;AAC5C,SACEC,OAAO,IAAIC,UAAU,EACrBC,MAAM,IAAIC,SAAS,EACnBC,UAAU,IAAIC,aAAa,EAC3BC,iBAAiB,IAAIC,oBAAoB,QACpC,mBAAmB;AAE1B,IAAIP,OAAO,GAAG,KAAK;AACnB,IAAIE,MAAM,GAAG,KAAK;AAClB,IAAIE,UAAU,GAAG,KAAK;AACtB,IAAIE,iBAAiB,GAAG,KAAK;AAE7B,IAAIE,UAAU,CAACC,cAAc,KAAKV,WAAW,CAACW,WAAW,EAAE;EACzDV,OAAO,GAAGC,UAAU;EACpBC,MAAM,GAAGC,SAAS;EAClBC,UAAU,GAAGC,aAAa;EAC1BC,iBAAiB,GAAGC,oBAAoB;AAC1C;AAEA,SACEP,OAAO,EACP;AACAE,MAAM,EACN;AACAE,UAAU,EACVE,iBAAiB","ignoreList":[]}

package/lib/module/WorkletsError.js

@@ -0,0 +1,29 @@
+'use strict';
+
+import { RuntimeKind } from './runtimeKind';
+function WorkletsErrorConstructor(message) {
+  'worklet';
+
+  const prefix = '[Worklets]';
+
+  // eslint-disable-next-line reanimated/use-worklets-error
+  const errorInstance = new Error(message ? `${prefix} ${message}` : prefix);
+  errorInstance.name = `WorkletsError`;
+  return errorInstance;
+}
+
+/**
+ * Registers WorkletsError in the global scope. Register only for Worklet
+ * runtimes.
+ */
+export function registerWorkletsError() {
+  'worklet';
+
+  if (globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
+    globalThis.WorkletsError = WorkletsErrorConstructor;
+  }
+}
+export const WorkletsError = WorkletsErrorConstructor;
+
+// signed type
+//# sourceMappingURL=WorkletsError.js.map

package/lib/module/WorkletsError.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RuntimeKind","WorkletsErrorConstructor","message","prefix","errorInstance","Error","name","registerWorkletsError","globalThis","__RUNTIME_KIND","ReactNative","WorkletsError"],"sourceRoot":"../../src","sources":["WorkletsError.ts"],"mappings":"AAAA,YAAY;;AAEZ,SAASA,WAAW,QAAQ,eAAe;AAE3C,SAASC,wBAAwBA,CAACC,OAAgB,EAAiB;EACjE,SAAS;;EACT,MAAMC,MAAM,GAAG,YAAY;;EAE3B;EACA,MAAMC,aAAa,GAAG,IAAIC,KAAK,CAACH,OAAO,GAAG,GAAGC,MAAM,IAAID,OAAO,EAAE,GAAGC,MAAM,CAAC;EAC1EC,aAAa,CAACE,IAAI,GAAG,eAAe;EACpC,OAAOF,aAAa;AACtB;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASG,qBAAqBA,CAAA,EAAG;EACtC,SAAS;;EACT,IAAIC,UAAU,CAACC,cAAc,KAAKT,WAAW,CAACU,WAAW,EAAE;IACzDF,UAAU,CAACG,aAAa,GACtBV,wBAAqD;EACzD;AACF;AAEA,OAAO,MAAMU,aAAa,GACxBV,wBAAqD;;AAEG","ignoreList":[]}

package/lib/module/WorkletsModule/JSWorklets.js

@@ -0,0 +1,111 @@
+'use strict';
+
+import { IS_JEST } from '../PlatformChecker';
+import { mockedRequestAnimationFrame } from '../runLoop/uiRuntime/mockedRequestAnimationFrame';
+import { WorkletsError } from '../WorkletsError';
+export function createJSWorkletsModule() {
+  return new JSWorklets();
+}
+
+// In Node.js environments (like when static rendering with Expo Router)
+// requestAnimationFrame is unavailable, so we use our mock.
+// It also has to be mocked for Jest purposes (see `initializeUIRuntime`).
+const requestAnimationFrameImpl = IS_JEST || !globalThis.requestAnimationFrame ? mockedRequestAnimationFrame : globalThis.requestAnimationFrame;
+class JSWorklets {
+  createSerializable() {
+    throw new WorkletsError('createSerializable should never be called in JSWorklets.');
+  }
+  createSerializableString() {
+    throw new WorkletsError('createSerializableString should never be called in JSWorklets.');
+  }
+  createSerializableNumber() {
+    throw new WorkletsError('createSerializableNumber should never be called in JSWorklets.');
+  }
+  createSerializableBoolean() {
+    throw new WorkletsError('createSerializableBoolean should never be called in JSWorklets.');
+  }
+  createSerializableBigInt() {
+    throw new WorkletsError('createSerializableBigInt should never be called in JSWorklets.');
+  }
+  createSerializableUndefined() {
+    throw new WorkletsError('createSerializableUndefined should never be called in JSWorklets.');
+  }
+  createSerializableNull() {
+    throw new WorkletsError('createSerializableNull should never be called in JSWorklets.');
+  }
+  createSerializableTurboModuleLike() {
+    throw new WorkletsError('createSerializableTurboModuleLike should never be called in JSWorklets.');
+  }
+  createSerializableObject() {
+    throw new WorkletsError('createSerializableObject should never be called in JSWorklets.');
+  }
+  createSerializableMap() {
+    throw new WorkletsError('createSerializableMap should never be called in JSWorklets.');
+  }
+  createSerializableSet() {
+    throw new WorkletsError('createSerializableSet should never be called in JSWorklets.');
+  }
+  createSerializableImport() {
+    throw new WorkletsError('createSerializableImport should never be called in JSWorklets.');
+  }
+  createSerializableHostObject() {
+    throw new WorkletsError('createSerializableHostObject should never be called in JSWorklets.');
+  }
+  createSerializableArray() {
+    throw new WorkletsError('createSerializableArray should never be called in JSWorklets.');
+  }
+  createSerializableInitializer() {
+    throw new WorkletsError('createSerializableInitializer should never be called in JSWorklets.');
+  }
+  createSerializableFunction() {
+    throw new WorkletsError('createSerializableFunction should never be called in JSWorklets.');
+  }
+  createSerializableWorklet() {
+    throw new WorkletsError('createSerializableWorklet should never be called in JSWorklets.');
+  }
+  scheduleOnUI(worklet) {
+    // TODO: `requestAnimationFrame` should be used exclusively in Reanimated
+
+    // @ts-ignore web implementation has still not been updated after the rewrite,
+    // this will be addressed once the web implementation updates are ready
+    requestAnimationFrameImpl(worklet);
+  }
+  executeOnUIRuntimeSync() {
+    throw new WorkletsError('`executeOnUIRuntimeSync` is not available in JSWorklets.');
+  }
+  createWorkletRuntime() {
+    throw new WorkletsError('createWorkletRuntime is not available in JSWorklets.');
+  }
+  scheduleOnRuntime() {
+    throw new WorkletsError('scheduleOnRuntime is not available in JSWorklets.');
+  }
+  createSynchronizable() {
+    throw new WorkletsError('createSynchronizable should never be called in JSWorklets.');
+  }
+  synchronizableGetDirty() {
+    throw new WorkletsError('synchronizableGetDirty should never be called in JSWorklets.');
+  }
+  synchronizableGetBlocking() {
+    throw new WorkletsError('synchronizableGetBlocking should never be called in JSWorklets.');
+  }
+  synchronizableSetBlocking() {
+    throw new WorkletsError('synchronizableSetBlocking should never be called in JSWorklets.');
+  }
+  synchronizableLock() {
+    throw new WorkletsError('synchronizableLock should never be called in JSWorklets.');
+  }
+  synchronizableUnlock() {
+    throw new WorkletsError('synchronizableUnlock should never be called in JSWorklets.');
+  }
+  reportFatalErrorOnJS() {
+    throw new WorkletsError('reportFatalErrorOnJS should never be called in JSWorklets.');
+  }
+  getStaticFeatureFlag() {
+    // mock implementation
+    return false;
+  }
+  setDynamicFeatureFlag() {
+    // noop
+  }
+}
+//# sourceMappingURL=JSWorklets.js.map

package/lib/module/WorkletsModule/JSWorklets.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["IS_JEST","mockedRequestAnimationFrame","WorkletsError","createJSWorkletsModule","JSWorklets","requestAnimationFrameImpl","globalThis","requestAnimationFrame","createSerializable","createSerializableString","createSerializableNumber","createSerializableBoolean","createSerializableBigInt","createSerializableUndefined","createSerializableNull","createSerializableTurboModuleLike","createSerializableObject","createSerializableMap","createSerializableSet","createSerializableImport","createSerializableHostObject","createSerializableArray","createSerializableInitializer","createSerializableFunction","createSerializableWorklet","scheduleOnUI","worklet","executeOnUIRuntimeSync","createWorkletRuntime","scheduleOnRuntime","createSynchronizable","synchronizableGetDirty","synchronizableGetBlocking","synchronizableSetBlocking","synchronizableLock","synchronizableUnlock","reportFatalErrorOnJS","getStaticFeatureFlag","setDynamicFeatureFlag"],"sourceRoot":"../../../src","sources":["WorkletsModule/JSWorklets.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/WorkletsModule/NativeWorklets.js

@@ -0,0 +1,126 @@
+'use strict';
+
+import { RuntimeKind } from '../runtimeKind';
+import { WorkletsTurboModule } from '../specs';
+import { checkCppVersion } from '../utils/checkCppVersion';
+import { jsVersion } from '../utils/jsVersion';
+import { WorkletsError } from '../WorkletsError';
+export function createNativeWorkletsModule() {
+  return new NativeWorklets();
+}
+class NativeWorklets {
+  #workletsModuleProxy;
+  #serializableUndefined;
+  #serializableNull;
+  #serializableTrue;
+  #serializableFalse;
+  constructor() {
+    globalThis._WORKLETS_VERSION_JS = jsVersion;
+    if (global.__workletsModuleProxy === undefined && globalThis.__RUNTIME_KIND === RuntimeKind.ReactNative) {
+      WorkletsTurboModule?.installTurboModule();
+    }
+    if (global.__workletsModuleProxy === undefined) {
+      throw new WorkletsError(`Native part of Worklets doesn't seem to be initialized.
+See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#native-part-of-worklets-doesnt-seem-to-be-initialized for more details.`);
+    }
+    if (__DEV__) {
+      checkCppVersion();
+    }
+    this.#workletsModuleProxy = global.__workletsModuleProxy;
+    this.#serializableNull = this.#workletsModuleProxy.createSerializableNull();
+    this.#serializableUndefined = this.#workletsModuleProxy.createSerializableUndefined();
+    this.#serializableTrue = this.#workletsModuleProxy.createSerializableBoolean(true);
+    this.#serializableFalse = this.#workletsModuleProxy.createSerializableBoolean(false);
+  }
+  createSerializable(value, shouldPersistRemote, nativeStateSource) {
+    return this.#workletsModuleProxy.createSerializable(value, shouldPersistRemote, nativeStateSource);
+  }
+  createSerializableImport(from, to) {
+    return this.#workletsModuleProxy.createSerializableImport(from, to);
+  }
+  createSerializableString(str) {
+    return this.#workletsModuleProxy.createSerializableString(str);
+  }
+  createSerializableNumber(num) {
+    return this.#workletsModuleProxy.createSerializableNumber(num);
+  }
+  createSerializableBoolean(bool) {
+    return bool ? this.#serializableTrue : this.#serializableFalse;
+  }
+  createSerializableBigInt(bigInt) {
+    return this.#workletsModuleProxy.createSerializableBigInt(bigInt);
+  }
+  createSerializableUndefined() {
+    return this.#serializableUndefined;
+  }
+  createSerializableNull() {
+    return this.#serializableNull;
+  }
+  createSerializableTurboModuleLike(props, proto) {
+    return this.#workletsModuleProxy.createSerializableTurboModuleLike(props, proto);
+  }
+  createSerializableObject(obj, shouldRetainRemote, nativeStateSource) {
+    return this.#workletsModuleProxy.createSerializableObject(obj, shouldRetainRemote, nativeStateSource);
+  }
+  createSerializableHostObject(obj) {
+    return this.#workletsModuleProxy.createSerializableHostObject(obj);
+  }
+  createSerializableArray(array, shouldRetainRemote) {
+    return this.#workletsModuleProxy.createSerializableArray(array, shouldRetainRemote);
+  }
+  createSerializableMap(keys, values) {
+    return this.#workletsModuleProxy.createSerializableMap(keys, values);
+  }
+  createSerializableSet(values) {
+    return this.#workletsModuleProxy.createSerializableSet(values);
+  }
+  createSerializableInitializer(obj) {
+    return this.#workletsModuleProxy.createSerializableInitializer(obj);
+  }
+  createSerializableFunction(func) {
+    return this.#workletsModuleProxy.createSerializableFunction(func);
+  }
+  createSerializableWorklet(worklet, shouldPersistRemote) {
+    return this.#workletsModuleProxy.createSerializableWorklet(worklet, shouldPersistRemote);
+  }
+  scheduleOnUI(serializable) {
+    return this.#workletsModuleProxy.scheduleOnUI(serializable);
+  }
+  executeOnUIRuntimeSync(serializable) {
+    return this.#workletsModuleProxy.executeOnUIRuntimeSync(serializable);
+  }
+  createWorkletRuntime(name, initializer, useDefaultQueue, customQueue, enableEventLoop) {
+    return this.#workletsModuleProxy.createWorkletRuntime(name, initializer, useDefaultQueue, customQueue, enableEventLoop);
+  }
+  scheduleOnRuntime(workletRuntime, serializableWorklet) {
+    return this.#workletsModuleProxy.scheduleOnRuntime(workletRuntime, serializableWorklet);
+  }
+  createSynchronizable(value) {
+    return this.#workletsModuleProxy.createSynchronizable(value);
+  }
+  synchronizableGetDirty(synchronizableRef) {
+    return this.#workletsModuleProxy.synchronizableGetDirty(synchronizableRef);
+  }
+  synchronizableGetBlocking(synchronizableRef) {
+    return this.#workletsModuleProxy.synchronizableGetBlocking(synchronizableRef);
+  }
+  synchronizableSetBlocking(synchronizableRef, value) {
+    return this.#workletsModuleProxy.synchronizableSetBlocking(synchronizableRef, value);
+  }
+  synchronizableLock(synchronizableRef) {
+    return this.#workletsModuleProxy.synchronizableLock(synchronizableRef);
+  }
+  synchronizableUnlock(synchronizableRef) {
+    return this.#workletsModuleProxy.synchronizableUnlock(synchronizableRef);
+  }
+  reportFatalErrorOnJS(message, stack, name, jsEngine) {
+    return this.#workletsModuleProxy.reportFatalErrorOnJS(message, stack, name, jsEngine);
+  }
+  getStaticFeatureFlag(name) {
+    return this.#workletsModuleProxy.getStaticFeatureFlag(name);
+  }
+  setDynamicFeatureFlag(name, value) {
+    this.#workletsModuleProxy.setDynamicFeatureFlag(name, value);
+  }
+}
+//# sourceMappingURL=NativeWorklets.js.map

package/lib/module/WorkletsModule/NativeWorklets.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RuntimeKind","WorkletsTurboModule","checkCppVersion","jsVersion","WorkletsError","createNativeWorkletsModule","NativeWorklets","workletsModuleProxy","serializableUndefined","serializableNull","serializableTrue","serializableFalse","constructor","globalThis","_WORKLETS_VERSION_JS","global","__workletsModuleProxy","undefined","__RUNTIME_KIND","ReactNative","installTurboModule","__DEV__","createSerializableNull","createSerializableUndefined","createSerializableBoolean","createSerializable","value","shouldPersistRemote","nativeStateSource","createSerializableImport","from","to","createSerializableString","str","createSerializableNumber","num","bool","createSerializableBigInt","bigInt","createSerializableTurboModuleLike","props","proto","createSerializableObject","obj","shouldRetainRemote","createSerializableHostObject","createSerializableArray","array","createSerializableMap","keys","values","createSerializableSet","createSerializableInitializer","createSerializableFunction","func","createSerializableWorklet","worklet","scheduleOnUI","serializable","executeOnUIRuntimeSync","createWorkletRuntime","name","initializer","useDefaultQueue","customQueue","enableEventLoop","scheduleOnRuntime","workletRuntime","serializableWorklet","createSynchronizable","synchronizableGetDirty","synchronizableRef","synchronizableGetBlocking","synchronizableSetBlocking","synchronizableLock","synchronizableUnlock","reportFatalErrorOnJS","message","stack","jsEngine","getStaticFeatureFlag","setDynamicFeatureFlag"],"sourceRoot":"../../../src","sources":["WorkletsModule/NativeWorklets.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/WorkletsModule/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+export { WorkletsModule } from './workletsModuleInstance';
+//# sourceMappingURL=index.js.map

package/lib/module/WorkletsModule/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WorkletsModule"],"sourceRoot":"../../../src","sources":["WorkletsModule/index.ts"],"mappings":"AAAA,YAAY;;AAEZ,SAASA,cAAc,QAAQ,0BAA0B","ignoreList":[]}