@depup/react-native-worklets 0.11.3-depup.0

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] Your installed version of React Native (${reactNativeVersion}) is not compatible with installed version of Worklets (${workletsVersion}). See the documentation for the list of supported versions: https://docs.swmansion.com/react-native-worklets/docs/guides/compatibility/`
+);
+process.exit(1);

package/scripts/worklets_utils.rb

@@ -0,0 +1,94 @@
+module WorkletsUtils
+  module_function
+
+  def try_to_parse_react_native_package_json(react_native_dir)
+    react_native_package_json_path = File.join(react_native_dir, '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 find_config()
+    result = {
+      :feature_flags_flag => nil,
+      :fetch_preview_flag => nil,
+      :is_reanimated_example_app => nil,
+      :react_native_version => nil,
+      :react_native_dir => nil,
+      :react_native_common_dir => nil,
+    }
+
+    react_native_dir = File.dirname(`cd "#{Pod::Config.instance.installation_root.to_s}" && node --print "require.resolve('react-native/package.json')"`)
+    react_native_json = try_to_parse_react_native_package_json(react_native_dir)
+
+    if react_native_json == nil
+      # user configuration, just in case
+      node_modules_dir = ENV["REACT_NATIVE_NODE_MODULES_DIR"]
+      react_native_json = try_to_parse_react_native_package_json(File.join(node_modules_dir, 'react-native'))
+    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[:react_native_version] = react_native_json['version']
+    result[:react_native_dir] = File.expand_path(react_native_dir)
+
+    pods_root = Pod::Config.instance.project_pods_root
+    react_native_common_dir_absolute = File.join(react_native_dir, '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
+
+    feature_flags = get_static_feature_flags()
+    result[:feature_flags_flag] = get_static_feature_flags_flag(feature_flags)
+    result[:fetch_preview_flag] = get_flag_from_feature_flags(feature_flags, 'FETCH_PREVIEW_ENABLED')
+
+    return result
+  end
+
+  def 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] Your installed version of React Native is not compatible with installed version of Worklets. See the documentation for the list of supported versions: https://docs.swmansion.com/react-native-worklets/docs/guides/compatibility/"
+    end
+  end
+
+  def get_flag_from_feature_flags(feature_flags, flag_name)
+    if feature_flags[flag_name] == 'true'
+      return "-DWORKLETS_#{flag_name}"
+    else
+      return ''
+    end
+  end
+
+  def 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
+  end
+
+  def get_static_feature_flags_flag(feature_flags)
+    return "-DWORKLETS_FEATURE_FLAGS=\"#{feature_flags.map { |key, value| "[#{key}:#{value}]" }.join('')}\""
+  end
+end

package/src/WorkletsModule/NativeWorklets.native.ts

@@ -0,0 +1,461 @@
+'use strict';
+
+import { isBundleModeEnabled } from '../debug/bundleMode';
+import { checkCppVersion } from '../debug/checkCppVersion';
+import { jsVersion } from '../debug/jsVersion';
+import { installCustomSerializableUnpacker } from '../memory/customSerializableUnpacker';
+import { installRemoteFunctionUnpacker } from '../memory/remoteFunctionUnpacker';
+import { installShareableGuestUnpacker } from '../memory/shareableGuestUnpacker';
+import { installShareableHostUnpacker } from '../memory/shareableHostUnpacker';
+import { installSynchronizableUnpacker } from '../memory/synchronizableUnpacker';
+import type {
+  RemoteFunction,
+  SerializableRef,
+  SynchronizableRef,
+} from '../memory/types';
+import { installValueUnpacker } from '../memory/valueUnpacker';
+import { isRNRuntime } from '../runtimeKind';
+import { WorkletsTurboModule } from '../specs';
+import type { WorkletFunction, WorkletRuntime } from '../types';
+import type {
+  IWorkletsModule,
+  WorkletsModuleProxy,
+} from './workletsModuleProxy';
+
+class NativeWorklets implements IWorkletsModule {
+  #workletsModuleProxy: WorkletsModuleProxy;
+  #serializableUndefined: SerializableRef<undefined>;
+  #serializableNull: SerializableRef<null>;
+  #serializableTrue: SerializableRef<boolean>;
+  #serializableFalse: SerializableRef<boolean>;
+
+  constructor() {
+    const bundleModeEnabled = isBundleModeEnabled();
+    globalThis._WORKLETS_VERSION_JS = jsVersion;
+    const onRNRuntime = isRNRuntime();
+    if (globalThis.__workletsModuleProxy === undefined && onRNRuntime) {
+      WorkletsTurboModule?.installTurboModule(bundleModeEnabled);
+      if (!bundleModeEnabled) {
+        installUnpackers(globalThis.__workletsModuleProxy);
+      }
+      WorkletsTurboModule?.start();
+    }
+    if (globalThis.__workletsModuleProxy === undefined) {
+      throw new Error(
+        `[Worklets] 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__) {
+      if (bundleModeEnabled) {
+        console.log(
+          '[Worklets] Bundle mode initialization: Downloaded the bundle for Worklet Runtimes.'
+        );
+      }
+      if (onRNRuntime) {
+        checkCppVersion();
+      }
+    }
+    this.#workletsModuleProxy = globalThis.__workletsModuleProxy;
+    this.#serializableNull = this.#workletsModuleProxy.createSerializableNull();
+    this.#serializableUndefined =
+      this.#workletsModuleProxy.createSerializableUndefined();
+    this.#serializableTrue =
+      this.#workletsModuleProxy.createSerializableBoolean(true);
+    this.#serializableFalse =
+      this.#workletsModuleProxy.createSerializableBoolean(false);
+  }
+
+  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 = false
+  ) {
+    return this.#workletsModuleProxy.createSerializableArray(
+      array,
+      shouldRetainRemote
+    );
+  }
+
+  createSerializableArrayBuffer(arrayBuffer: ArrayBuffer) {
+    return this.#workletsModuleProxy.createSerializableArrayBuffer(arrayBuffer);
+  }
+
+  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);
+  }
+
+  createSerializableError(
+    name: string,
+    message: string,
+    stack: string | undefined
+  ): SerializableRef<Error> {
+    return this.#workletsModuleProxy.createSerializableError(
+      name,
+      message,
+      stack
+    );
+  }
+
+  createSerializableRegExp(
+    pattern: string,
+    flags: string
+  ): SerializableRef<RegExp> {
+    return this.#workletsModuleProxy.createSerializableRegExp(pattern, flags);
+  }
+
+  createSerializableArrayBufferView<TValue extends ArrayBufferView>(
+    typeName: string,
+    buffer: ArrayBuffer,
+    byteOffset: number,
+    length: number
+  ): SerializableRef<TValue> {
+    return this.#workletsModuleProxy.createSerializableArrayBufferView<TValue>(
+      typeName,
+      buffer,
+      byteOffset,
+      length
+    );
+  }
+
+  createSerializableInitializer(obj: object) {
+    return this.#workletsModuleProxy.createSerializableInitializer(obj);
+  }
+
+  createSerializableNonWorkletFunction<TArgs extends unknown[], TReturn>(
+    fun: (...args: TArgs) => TReturn,
+    functionName: string | undefined
+  ): SerializableRef<(...args: TArgs) => TReturn> {
+    return this.#workletsModuleProxy.createSerializableNonWorkletFunction(
+      fun,
+      functionName
+    );
+  }
+
+  createSerializableWorklet(worklet: object, shouldPersistRemote: boolean) {
+    return this.#workletsModuleProxy.createSerializableWorklet(
+      worklet,
+      shouldPersistRemote
+    );
+  }
+
+  createCustomSerializable(
+    data: SerializableRef<unknown>,
+    typeId: number
+  ): SerializableRef<unknown> {
+    return this.#workletsModuleProxy.createCustomSerializable(data, typeId);
+  }
+
+  registerCustomSerializable(
+    determine: SerializableRef<object>,
+    pack: SerializableRef<object>,
+    unpack: SerializableRef<object>,
+    typeId: number
+  ): void {
+    this.#workletsModuleProxy.registerCustomSerializable(
+      determine,
+      pack,
+      unpack,
+      typeId
+    );
+  }
+
+  createShareable<TValue = unknown>(
+    hostRuntimeId: number,
+    initial: SerializableRef<TValue>,
+    initSynchronously: boolean,
+    decorateHost: SerializableRef,
+    decorateRef: SerializableRef
+  ): SerializableRef<TValue> {
+    return this.#workletsModuleProxy.createShareable(
+      hostRuntimeId,
+      initial,
+      initSynchronously,
+      decorateHost,
+      decorateRef
+    );
+  }
+
+  scheduleOnRN<TArgs extends unknown[]>(
+    fun: RemoteFunction | ((...args: TArgs) => unknown),
+    args: SerializableRef<TArgs> | undefined
+  ): void {
+    this.#workletsModuleProxy.scheduleOnRN(fun, args);
+  }
+
+  scheduleOnUI<TValue>(
+    serializableArrayOfWorklets: SerializableRef<TValue[]>,
+    scheduleStacks: string[] | undefined
+  ) {
+    return this.#workletsModuleProxy.scheduleOnUI(
+      serializableArrayOfWorklets,
+      scheduleStacks
+    );
+  }
+
+  runOnUISync<TValue, TReturn>(
+    worklet: SerializableRef<TValue>,
+    scheduleStack: string | undefined
+  ): TReturn {
+    return this.#workletsModuleProxy.runOnUISync(worklet, scheduleStack);
+  }
+
+  createWorkletRuntime(
+    name: string,
+    initializer: SerializableRef<() => void>,
+    useDefaultQueue: boolean,
+    customQueue: object | undefined,
+    enableEventLoop: boolean
+  ) {
+    return this.#workletsModuleProxy.createWorkletRuntime(
+      name,
+      initializer,
+      useDefaultQueue,
+      customQueue,
+      enableEventLoop
+    );
+  }
+
+  scheduleOnRuntime<TValue>(
+    workletRuntime: WorkletRuntime,
+    serializableWorklet: SerializableRef<TValue>,
+    scheduleStack: string | undefined
+  ) {
+    return this.#workletsModuleProxy.scheduleOnRuntime(
+      workletRuntime,
+      serializableWorklet,
+      scheduleStack
+    );
+  }
+
+  scheduleOnRuntimeWithId<TValue>(
+    runtimeId: number,
+    worklet: SerializableRef<TValue>,
+    scheduleStack: string | undefined
+  ) {
+    return this.#workletsModuleProxy.scheduleOnRuntimeWithId(
+      runtimeId,
+      worklet,
+      scheduleStack
+    );
+  }
+
+  runOnRuntimeSync<TValue, TReturn>(
+    workletRuntime: WorkletRuntime,
+    worklet: SerializableRef<TValue>,
+    scheduleStack: string | undefined
+  ): TReturn {
+    return this.#workletsModuleProxy.runOnRuntimeSync(
+      workletRuntime,
+      worklet,
+      scheduleStack
+    );
+  }
+
+  runOnRuntimeSyncWithId<TValue, TReturn>(
+    runtimeId: number,
+    worklet: SerializableRef<TValue>,
+    scheduleStack: string | undefined
+  ): TReturn {
+    return this.#workletsModuleProxy.runOnRuntimeSyncWithId(
+      runtimeId,
+      worklet,
+      scheduleStack
+    );
+  }
+
+  handlePromise<TValue>(
+    resolveOrReject:
+      | ((value: TValue | PromiseLike<TValue>) => void)
+      | RemoteFunction,
+    valueOrError: SerializableRef<TValue>
+  ) {
+    return this.#workletsModuleProxy.handlePromise(
+      resolveOrReject,
+      valueOrError
+    );
+  }
+
+  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) {
+    return this.#workletsModuleProxy.reportFatalErrorOnJS(message, stack, name);
+  }
+
+  getStaticFeatureFlag(name: string): boolean {
+    return this.#workletsModuleProxy.getStaticFeatureFlag(name);
+  }
+
+  setDynamicFeatureFlag(name: string, value: boolean) {
+    this.#workletsModuleProxy.setDynamicFeatureFlag(name, value);
+  }
+
+  getUIRuntimeHolder(): object {
+    return this.#workletsModuleProxy.getUIRuntimeHolder();
+  }
+
+  getUISchedulerHolder(): object {
+    return this.#workletsModuleProxy.getUISchedulerHolder();
+  }
+
+  toggleSlowAnimationsOnUIRuntime(): boolean {
+    return WorkletsTurboModule?.toggleSlowAnimationsOnUIRuntime() ?? false;
+  }
+}
+
+export const WorkletsModule: IWorkletsModule = new NativeWorklets();
+
+function installUnpackers(workletsModuleProxy: WorkletsModuleProxy) {
+  const value = (installValueUnpacker as WorkletFunction).__initData!;
+  const synchronizable = (installSynchronizableUnpacker as WorkletFunction)
+    .__initData!;
+  const customSerializable = (
+    installCustomSerializableUnpacker as WorkletFunction
+  ).__initData!;
+  const shareableHost = (installShareableHostUnpacker as WorkletFunction)
+    .__initData!;
+  const shareableGuest = (installShareableGuestUnpacker as WorkletFunction)
+    .__initData!;
+  const remoteFunction = (installRemoteFunctionUnpacker as WorkletFunction)
+    .__initData!;
+
+  if (value.bytecode !== undefined) {
+    if (__DEV__) {
+      throw new Error(
+        '[Worklets] Unpackers were compiled to Hermes bytecode in a development build, which is not supported.'
+      );
+    }
+    workletsModuleProxy.loadUnpackersWithBytecode(
+      value.bytecode,
+      synchronizable.bytecode!,
+      customSerializable.bytecode!,
+      shareableHost.bytecode!,
+      shareableGuest.bytecode!,
+      remoteFunction.bytecode!
+    );
+  } else {
+    workletsModuleProxy.loadUnpackersWithCode(
+      value.code!,
+      value.location ?? '',
+      value.sourceMap ?? '',
+      synchronizable.code!,
+      synchronizable.location ?? '',
+      synchronizable.sourceMap ?? '',
+      customSerializable.code!,
+      customSerializable.location ?? '',
+      customSerializable.sourceMap ?? '',
+      shareableHost.code!,
+      shareableHost.location ?? '',
+      shareableHost.sourceMap ?? '',
+      shareableGuest.code!,
+      shareableGuest.location ?? '',
+      shareableGuest.sourceMap ?? '',
+      remoteFunction.code!,
+      remoteFunction.location ?? '',
+      remoteFunction.sourceMap ?? ''
+    );
+  }
+}

package/src/WorkletsModule/NativeWorklets.ts

@@ -0,0 +1,5 @@
+'use strict';
+
+import type { IWorkletsModule } from './workletsModuleProxy';
+
+export const WorkletsModule: IWorkletsModule = null!;