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

package/react-native.config.js

@@ -0,0 +1,21 @@
+module.exports = {
+  dependencies: {
+    '@amazon-devices/react-native-kepler': {
+      platforms: {
+        kepler: null, // do not use platform definition from @react-native-kepler
+      },
+    },
+  },
+  dependency: {
+    platforms: {
+      kepler: {
+        autolink: {
+          Worklets: {
+            libraryName: 'libreact-native-worklets-4.so.4.0',
+            turbomodules: ['WorkletsModule'],
+          },
+        },
+      },
+    },
+  },
+};

package/scripts/validate-react-native-version.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const semverSatisfies = require('semver/functions/satisfies');
+const semverPrerelease = require('semver/functions/prerelease');
+const path = require('path');
+
+const packageJsonPath = path.resolve(__dirname, '../package.json');
+const packageJson = require(packageJsonPath);
+const workletsVersion = packageJson.version;
+const compatibilityFile = require('../compatibility.json');
+
+const reactNativeVersion = process.argv[2];
+const supportedRNVersions = [];
+
+if (semverPrerelease(reactNativeVersion)) {
+  // Don't perform any checks for pre-release versions, like nightlies or
+  // feature previews. The user knows what they're doing.
+  process.exit(0);
+}
+
+for (const key in compatibilityFile) {
+  if (semverSatisfies(workletsVersion, key)) {
+    // @ts-ignore
+    supportedRNVersions.push(...compatibilityFile[key]['react-native']);
+  }
+}
+
+// If user uses a version of Reanimated that is not listed in the compatibility file, we skip the check
+if (supportedRNVersions.length === 0) {
+  process.exit(0);
+}
+
+for (const version of supportedRNVersions) {
+  if (semverSatisfies(reactNativeVersion, `${version}.x`)) {
+    process.exit(0);
+  }
+}
+
+// eslint-disable-next-line reanimated/use-logger
+console.error(
+  `[Worklets] React Native ${reactNativeVersion} version is not compatible with Worklets ${workletsVersion}`
+);
+process.exit(1);

package/scripts/worklets_utils.rb

@@ -0,0 +1,94 @@
+def worklets_try_to_parse_react_native_package_json(node_modules_dir)
+  react_native_package_json_path = File.join(node_modules_dir, 'react-native/package.json')
+  if !File.exist?(react_native_package_json_path)
+    return nil
+  end
+  return JSON.parse(File.read(react_native_package_json_path))
+end
+
+def worklets_find_config()
+  result = {
+    :bundle_mode => nil,
+    :is_reanimated_example_app => nil,
+    :is_tvos_target => nil,
+    :react_native_version => nil,
+    :react_native_minor_version => nil,
+    :react_native_node_modules_dir => nil,
+    :react_native_common_dir => nil,
+    :dynamic_frameworks_worklets_dir => nil,
+  }
+
+  result[:bundle_mode] = ENV["WORKLETS_BUNDLE_MODE"] == "1"
+
+  react_native_node_modules_dir = File.join(File.dirname(`cd "#{Pod::Config.instance.installation_root.to_s}" && node --print "require.resolve('react-native/package.json')"`), '..')
+  react_native_json = worklets_try_to_parse_react_native_package_json(react_native_node_modules_dir)
+
+  if react_native_json == nil
+    # user configuration, just in case
+    node_modules_dir = ENV["REACT_NATIVE_NODE_MODULES_DIR"]
+    react_native_json = worklets_try_to_parse_react_native_package_json(node_modules_dir)
+  end
+
+  if react_native_json == nil
+    raise '[Worklets] Unable to recognize your `react-native` version. Please set environmental variable with `react-native` location: `export REACT_NATIVE_NODE_MODULES_DIR="<path to react-native>" && pod install`.'
+  end
+
+  result[:is_reanimated_example_app] = ENV["IS_REANIMATED_EXAMPLE_APP"] != nil
+  result[:is_tvos_target] = react_native_json['name'] == 'react-native-tvos'
+  result[:react_native_version] = react_native_json['version']
+  result[:react_native_minor_version] = react_native_json['version'].split('.')[1].to_i
+  if result[:react_native_minor_version] == 0 # nightly
+    result[:react_native_minor_version] = 1000
+  end
+  result[:react_native_node_modules_dir] = File.expand_path(react_native_node_modules_dir)
+
+  pods_root = Pod::Config.instance.project_pods_root
+  react_native_common_dir_absolute = File.join(react_native_node_modules_dir, 'react-native', 'ReactCommon')
+  react_native_common_dir_relative = Pathname.new(react_native_common_dir_absolute).relative_path_from(pods_root).to_s
+  result[:react_native_common_dir] = react_native_common_dir_relative
+
+  react_native_worklets_dir_absolute = File.join(__dir__, '..')
+  react_native_worklets_dir_relative = Pathname.new(react_native_worklets_dir_absolute).relative_path_from(pods_root).to_s
+  result[:dynamic_frameworks_worklets_dir] = react_native_worklets_dir_relative
+
+  return result
+end
+
+def worklets_assert_minimal_react_native_version(config)
+  validate_react_native_version_script = File.expand_path(File.join(__dir__, 'validate-react-native-version.js'))
+  unless system("node \"#{validate_react_native_version_script}\" #{config[:react_native_version]}")
+    raise "[Worklets] React Native version is not compatible with Worklets"
+  end
+end
+
+def worklets_assert_new_architecture_enabled(new_arch_enabled)
+  if !new_arch_enabled
+    raise "[Worklets] Worklets require the New Architecture to be enabled. If you have `RCT_NEW_ARCH_ENABLED=0` set in your environment you should remove it."
+  end
+end
+
+def worklets_get_static_feature_flags()
+  feature_flags = {}
+
+  static_feature_flags_path = File.path('./src/featureFlags/staticFlags.json')
+  if !File.exist?(static_feature_flags_path)
+    raise "[Worklets] Feature flags file not found at #{static_feature_flags_path}."
+  end
+  static_feature_flags_json = JSON.parse(File.read(static_feature_flags_path))
+  static_feature_flags_json.each do |key, value|
+    feature_flags[key] = value.to_s
+  end
+
+  package_json_path = File.join(Pod::Config.instance.installation_root.to_s, '..', 'package.json')
+  if File.exist?(package_json_path)
+    package_json = JSON.parse(File.read(package_json_path))
+    if package_json['worklets'] && package_json['worklets']['staticFeatureFlags']
+      feature_flags_json = package_json['worklets']['staticFeatureFlags']
+      feature_flags_json.each do |key, value|
+        feature_flags[key] = value.to_s
+      end
+    end
+  end
+
+  return feature_flags.map { |key, value| "[#{key}:#{value}]" }.join('')
+end

package/src/PlatformChecker/PlatformChecker.ts

@@ -0,0 +1,7 @@
+'use strict';
+import { Platform } from 'react-native';
+
+export const IS_JEST: boolean = !!process.env.JEST_WORKER_ID;
+export const IS_WEB: boolean = Platform.OS === 'web';
+export const IS_WINDOWS: boolean = Platform.OS === 'windows';
+export const SHOULD_BE_USE_WEB: boolean = IS_JEST || IS_WEB || IS_WINDOWS;

package/src/PlatformChecker/index.ts

@@ -0,0 +1,30 @@
+'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,
+};

package/src/WorkletsError.ts

@@ -0,0 +1,36 @@
+'use strict';
+
+import { RuntimeKind } from './runtimeKind';
+
+function WorkletsErrorConstructor(message?: string): WorkletsError {
+  '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 as WorkletsError;
+}
+
+/**
+ * Registers WorkletsError in the global scope. Register only for Worklet
+ * runtimes.
+ */
+export function registerWorkletsError() {
+  'worklet';
+  if (globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
+    globalThis.WorkletsError =
+      WorkletsErrorConstructor as IWorkletsErrorConstructor;
+  }
+}
+
+export const WorkletsError =
+  WorkletsErrorConstructor as IWorkletsErrorConstructor;
+
+export type WorkletsError = Error & { name: 'Worklets' }; // signed type
+
+export interface IWorkletsErrorConstructor extends Error {
+  new (message?: string): WorkletsError;
+  (message?: string): WorkletsError;
+  readonly prototype: WorkletsError;
+}

package/src/WorkletsModule/JSWorklets.ts

@@ -0,0 +1,200 @@
+'use strict';
+
+import { IS_JEST } from '../PlatformChecker';
+import { mockedRequestAnimationFrame } from '../runLoop/uiRuntime/mockedRequestAnimationFrame';
+import { WorkletsError } from '../WorkletsError';
+import type { SerializableRef } from '../workletTypes';
+import type { IWorkletsModule } from './workletsModuleProxy';
+
+export function createJSWorkletsModule(): IWorkletsModule {
+  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 implements IWorkletsModule {
+  createSerializable(): never {
+    throw new WorkletsError(
+      'createSerializable should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableString(): never {
+    throw new WorkletsError(
+      'createSerializableString should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableNumber(): never {
+    throw new WorkletsError(
+      'createSerializableNumber should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableBoolean(): never {
+    throw new WorkletsError(
+      'createSerializableBoolean should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableBigInt(): never {
+    throw new WorkletsError(
+      'createSerializableBigInt should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableUndefined(): never {
+    throw new WorkletsError(
+      'createSerializableUndefined should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableNull(): never {
+    throw new WorkletsError(
+      'createSerializableNull should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableTurboModuleLike(): never {
+    throw new WorkletsError(
+      'createSerializableTurboModuleLike should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableObject(): never {
+    throw new WorkletsError(
+      'createSerializableObject should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableMap(): never {
+    throw new WorkletsError(
+      'createSerializableMap should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableSet(): never {
+    throw new WorkletsError(
+      'createSerializableSet should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableImport(): never {
+    throw new WorkletsError(
+      'createSerializableImport should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableHostObject(): never {
+    throw new WorkletsError(
+      'createSerializableHostObject should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableArray(): never {
+    throw new WorkletsError(
+      'createSerializableArray should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableInitializer(): never {
+    throw new WorkletsError(
+      'createSerializableInitializer should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableFunction(): never {
+    throw new WorkletsError(
+      'createSerializableFunction should never be called in JSWorklets.'
+    );
+  }
+
+  createSerializableWorklet(): never {
+    throw new WorkletsError(
+      'createSerializableWorklet should never be called in JSWorklets.'
+    );
+  }
+
+  scheduleOnUI<TValue>(worklet: SerializableRef<TValue>) {
+    // 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(): never {
+    throw new WorkletsError(
+      '`executeOnUIRuntimeSync` is not available in JSWorklets.'
+    );
+  }
+
+  createWorkletRuntime(): never {
+    throw new WorkletsError(
+      'createWorkletRuntime is not available in JSWorklets.'
+    );
+  }
+
+  scheduleOnRuntime(): never {
+    throw new WorkletsError(
+      'scheduleOnRuntime is not available in JSWorklets.'
+    );
+  }
+
+  createSynchronizable(): never {
+    throw new WorkletsError(
+      'createSynchronizable should never be called in JSWorklets.'
+    );
+  }
+
+  synchronizableGetDirty(): never {
+    throw new WorkletsError(
+      'synchronizableGetDirty should never be called in JSWorklets.'
+    );
+  }
+
+  synchronizableGetBlocking(): never {
+    throw new WorkletsError(
+      'synchronizableGetBlocking should never be called in JSWorklets.'
+    );
+  }
+
+  synchronizableSetBlocking(): never {
+    throw new WorkletsError(
+      'synchronizableSetBlocking should never be called in JSWorklets.'
+    );
+  }
+
+  synchronizableLock(): never {
+    throw new WorkletsError(
+      'synchronizableLock should never be called in JSWorklets.'
+    );
+  }
+
+  synchronizableUnlock(): never {
+    throw new WorkletsError(
+      'synchronizableUnlock should never be called in JSWorklets.'
+    );
+  }
+
+  reportFatalErrorOnJS(): never {
+    throw new WorkletsError(
+      'reportFatalErrorOnJS should never be called in JSWorklets.'
+    );
+  }
+
+  getStaticFeatureFlag(): boolean {
+    // mock implementation
+    return false;
+  }
+
+  setDynamicFeatureFlag() {
+    // noop
+  }
+}

package/src/WorkletsModule/NativeWorklets.ts

@@ -0,0 +1,256 @@
+'use strict';
+
+import { RuntimeKind } from '../runtimeKind';
+import { WorkletsTurboModule } from '../specs';
+import type { SynchronizableRef } from '../synchronizable';
+import { checkCppVersion } from '../utils/checkCppVersion';
+import { jsVersion } from '../utils/jsVersion';
+import { WorkletsError } from '../WorkletsError';
+import type { SerializableRef, WorkletRuntime } from '../workletTypes';
+import type {
+  IWorkletsModule,
+  WorkletsModuleProxy,
+} from './workletsModuleProxy';
+
+export function createNativeWorkletsModule(): IWorkletsModule {
+  return new NativeWorklets();
+}
+
+class NativeWorklets implements IWorkletsModule {
+  #workletsModuleProxy: WorkletsModuleProxy;
+  #serializableUndefined: SerializableRef<undefined>;
+  #serializableNull: SerializableRef<null>;
+  #serializableTrue: SerializableRef<boolean>;
+  #serializableFalse: SerializableRef<boolean>;
+
+  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<TValue>(
+    value: TValue,
+    shouldPersistRemote: boolean,
+    nativeStateSource?: object
+  ) {
+    return this.#workletsModuleProxy.createSerializable(
+      value,
+      shouldPersistRemote,
+      nativeStateSource
+    );
+  }
+
+  createSerializableImport<TValue>(
+    from: string,
+    to: string
+  ): SerializableRef<TValue> {
+    return this.#workletsModuleProxy.createSerializableImport(from, to);
+  }
+
+  createSerializableString(str: string) {
+    return this.#workletsModuleProxy.createSerializableString(str);
+  }
+
+  createSerializableNumber(num: number) {
+    return this.#workletsModuleProxy.createSerializableNumber(num);
+  }
+
+  createSerializableBoolean(bool: boolean) {
+    return bool ? this.#serializableTrue : this.#serializableFalse;
+  }
+
+  createSerializableBigInt(bigInt: bigint) {
+    return this.#workletsModuleProxy.createSerializableBigInt(bigInt);
+  }
+
+  createSerializableUndefined() {
+    return this.#serializableUndefined;
+  }
+
+  createSerializableNull() {
+    return this.#serializableNull;
+  }
+
+  createSerializableTurboModuleLike<
+    TProps extends object,
+    TProto extends object,
+  >(props: TProps, proto: TProto): SerializableRef<TProps> {
+    return this.#workletsModuleProxy.createSerializableTurboModuleLike(
+      props,
+      proto
+    );
+  }
+
+  createSerializableObject<T extends object>(
+    obj: T,
+    shouldRetainRemote: boolean,
+    nativeStateSource?: object
+  ): SerializableRef<T> {
+    return this.#workletsModuleProxy.createSerializableObject(
+      obj,
+      shouldRetainRemote,
+      nativeStateSource
+    );
+  }
+
+  createSerializableHostObject<T extends object>(obj: T) {
+    return this.#workletsModuleProxy.createSerializableHostObject(obj);
+  }
+
+  createSerializableArray(array: unknown[], shouldRetainRemote: boolean) {
+    return this.#workletsModuleProxy.createSerializableArray(
+      array,
+      shouldRetainRemote
+    );
+  }
+
+  createSerializableMap<TKey, TValue>(
+    keys: TKey[],
+    values: TValue[]
+  ): SerializableRef<Map<TKey, TValue>> {
+    return this.#workletsModuleProxy.createSerializableMap(keys, values);
+  }
+
+  createSerializableSet<TValues>(
+    values: TValues[]
+  ): SerializableRef<Set<TValues>> {
+    return this.#workletsModuleProxy.createSerializableSet(values);
+  }
+
+  createSerializableInitializer(obj: object) {
+    return this.#workletsModuleProxy.createSerializableInitializer(obj);
+  }
+
+  createSerializableFunction<TArgs extends unknown[], TReturn>(
+    func: (...args: TArgs) => TReturn
+  ) {
+    return this.#workletsModuleProxy.createSerializableFunction(func);
+  }
+
+  createSerializableWorklet(worklet: object, shouldPersistRemote: boolean) {
+    return this.#workletsModuleProxy.createSerializableWorklet(
+      worklet,
+      shouldPersistRemote
+    );
+  }
+
+  scheduleOnUI<TValue>(serializable: SerializableRef<TValue>) {
+    return this.#workletsModuleProxy.scheduleOnUI(serializable);
+  }
+
+  executeOnUIRuntimeSync<TValue, TReturn>(
+    serializable: SerializableRef<TValue>
+  ): TReturn {
+    return this.#workletsModuleProxy.executeOnUIRuntimeSync(serializable);
+  }
+
+  createWorkletRuntime(
+    name: string,
+    initializer: SerializableRef<() => void>,
+    useDefaultQueue: boolean,
+    customQueue: object | undefined,
+    enableEventLoop: boolean
+  ) {
+    return this.#workletsModuleProxy.createWorkletRuntime(
+      name,
+      initializer,
+      useDefaultQueue,
+      customQueue,
+      enableEventLoop
+    );
+  }
+
+  scheduleOnRuntime<T>(
+    workletRuntime: WorkletRuntime,
+    serializableWorklet: SerializableRef<T>
+  ) {
+    return this.#workletsModuleProxy.scheduleOnRuntime(
+      workletRuntime,
+      serializableWorklet
+    );
+  }
+
+  createSynchronizable<TValue>(value: TValue): SynchronizableRef<TValue> {
+    return this.#workletsModuleProxy.createSynchronizable(value);
+  }
+
+  synchronizableGetDirty<TValue>(
+    synchronizableRef: SynchronizableRef<TValue>
+  ): TValue {
+    return this.#workletsModuleProxy.synchronizableGetDirty(synchronizableRef);
+  }
+
+  synchronizableGetBlocking<TValue>(
+    synchronizableRef: SynchronizableRef<TValue>
+  ): TValue {
+    return this.#workletsModuleProxy.synchronizableGetBlocking(
+      synchronizableRef
+    );
+  }
+
+  synchronizableSetBlocking<TValue>(
+    synchronizableRef: SynchronizableRef<TValue>,
+    value: SerializableRef<TValue>
+  ) {
+    return this.#workletsModuleProxy.synchronizableSetBlocking(
+      synchronizableRef,
+      value
+    );
+  }
+
+  synchronizableLock<TValue>(
+    synchronizableRef: SynchronizableRef<TValue>
+  ): void {
+    return this.#workletsModuleProxy.synchronizableLock(synchronizableRef);
+  }
+
+  synchronizableUnlock<TValue>(
+    synchronizableRef: SynchronizableRef<TValue>
+  ): void {
+    return this.#workletsModuleProxy.synchronizableUnlock(synchronizableRef);
+  }
+
+  reportFatalErrorOnJS(
+    message: string,
+    stack: string,
+    name: string,
+    jsEngine: string
+  ) {
+    return this.#workletsModuleProxy.reportFatalErrorOnJS(
+      message,
+      stack,
+      name,
+      jsEngine
+    );
+  }
+
+  getStaticFeatureFlag(name: string): boolean {
+    return this.#workletsModuleProxy.getStaticFeatureFlag(name);
+  }
+
+  setDynamicFeatureFlag(name: string, value: boolean) {
+    this.#workletsModuleProxy.setDynamicFeatureFlag(name, value);
+  }
+}

package/src/WorkletsModule/index.ts

@@ -0,0 +1,7 @@
+'use strict';
+
+export { WorkletsModule } from './workletsModuleInstance';
+export type {
+  IWorkletsModule,
+  WorkletsModuleProxy,
+} from './workletsModuleProxy';