react-native-worklets 0.3.0 → 0.4.0-bundle-mode-preview-1

package/src/PlatformChecker/index.ts

@@ -0,0 +1,29 @@
+'use strict';
+
+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._WORKLET) {
+  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

@@ -1,9 +1,10 @@
-/* eslint-disable reanimated/use-worklets-error */
 'use strict';
 
 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;

package/src/WorkletsModule/JSWorklets.ts

@@ -1,8 +1,7 @@
-/* eslint-disable reanimated/use-reanimated-error */
 'use strict';
 
-import { mockedRequestAnimationFrame } from '../animationFrameQueue/mockedRequestAnimationFrame';
-import { isJest } from '../PlatformChecker';
+import { IS_JEST } from '../PlatformChecker';
+import { mockedRequestAnimationFrame } from '../runLoop/mockedRequestAnimationFrame';
 import { WorkletsError } from '../WorkletsError';
 import type { ShareableRef, WorkletRuntime } from '../workletTypes';
 import type { IWorkletsModule } from './workletsModuleProxy';
@@ -15,7 +14,7 @@ export function createJSWorkletsModule(): IWorkletsModule {
 // requestAnimationFrame is unavailable, so we use our mock.
 // It also has to be mocked for Jest purposes (see `initializeUIRuntime`).
 const requestAnimationFrameImpl =
-  isJest() || !globalThis.requestAnimationFrame
+  IS_JEST || !globalThis.requestAnimationFrame
     ? mockedRequestAnimationFrame
     : globalThis.requestAnimationFrame;
 
@@ -62,6 +61,68 @@ class JSWorklets implements IWorkletsModule {
     );
   }
 
+  makeShareableTurboModuleLike<T extends object>(): ShareableRef<T> {
+    throw new WorkletsError(
+      'makeShareableTurboModuleLike should never be called in JSWorklets.'
+    );
+  }
+
+  makeShareableObject<T extends object>(): ShareableRef<T> {
+    throw new WorkletsError(
+      'makeShareableObject should never be called in JSWorklets.'
+    );
+  }
+
+  makeShareableMap(): never {
+    throw new WorkletsError(
+      'makeShareableMap should never be called in JSWorklets.'
+    );
+  }
+
+  makeShareableSet(): never {
+    throw new WorkletsError(
+      'makeShareableSet should never be called in JSWorklets.'
+    );
+  }
+
+  makeShareableImport(): never {
+    throw new WorkletsError(
+      'makeShareableImport should never be called in JSWorklets.'
+    );
+  }
+
+  makeShareableHostObject<T extends object>(): ShareableRef<T> {
+    throw new WorkletsError(
+      'makeShareableHostObject should never be called in JSWorklets.'
+    );
+  }
+
+  makeShareableArray(): ShareableRef<unknown[]> {
+    throw new WorkletsError(
+      'makeShareableArray should never be called in JSWorklets.'
+    );
+  }
+
+  makeShareableInitializer(): ShareableRef<object> {
+    throw new WorkletsError(
+      'makeShareableInitializer should never be called in JSWorklets.'
+    );
+  }
+
+  makeShareableFunction<TArgs extends unknown[], TReturn>(
+    _func: (...args: TArgs) => TReturn
+  ): ShareableRef<TReturn> {
+    throw new WorkletsError(
+      'makeShareableRemoteFunction should never be called in JSWorklets.'
+    );
+  }
+
+  makeShareableWorklet(): ShareableRef<object> {
+    throw new WorkletsError(
+      'makeShareableWorklet should never be called in JSWorklets.'
+    );
+  }
+
   scheduleOnUI<TValue>(worklet: ShareableRef<TValue>) {
     // TODO: `requestAnimationFrame` should be used exclusively in Reanimated
 
@@ -90,4 +151,10 @@ class JSWorklets implements IWorkletsModule {
       'scheduleOnRuntime is not available in JSWorklets.'
     );
   }
+
+  reportFatalErrorOnJS(): never {
+    throw new WorkletsError(
+      'reportFatalErrorOnJS should never be called in JSWorklets.'
+    );
+  }
 }

package/src/WorkletsModule/NativeWorklets.ts

@@ -1,18 +1,18 @@
-/* eslint-disable @typescript-eslint/unbound-method */
 'use strict';
 
 import { WorkletsTurboModule } from '../specs';
 import { WorkletsError } from '../WorkletsError';
 import type { ShareableRef, WorkletRuntime } from '../workletTypes';
-import type { WorkletsModuleProxy } from './workletsModuleProxy';
-
-export interface IWorkletsModule extends WorkletsModuleProxy {}
+import type {
+  IWorkletsModule,
+  WorkletsModuleProxy,
+} from './workletsModuleProxy';
 
 export function createNativeWorkletsModule(): IWorkletsModule {
   return new NativeWorklets();
 }
 
-class NativeWorklets {
+class NativeWorklets implements IWorkletsModule {
   #workletsModuleProxy: WorkletsModuleProxy;
   #shareableUndefined: ShareableRef<undefined>;
   #shareableNull: ShareableRef<null>;
@@ -20,7 +20,7 @@ class NativeWorklets {
   #shareableFalse: ShareableRef<boolean>;
 
   constructor() {
-    if (global.__workletsModuleProxy === undefined) {
+    if (global.__workletsModuleProxy === undefined && !globalThis._WORKLET) {
       WorkletsTurboModule?.installTurboModule();
     }
     if (global.__workletsModuleProxy === undefined) {
@@ -29,21 +29,7 @@ class NativeWorklets {
 See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#native-part-of-reanimated-doesnt-seem-to-be-initialized for more details.`
       );
     }
-    this.#workletsModuleProxy = {
-      scheduleOnUI: global.__workletsModuleProxy.scheduleOnUI,
-      scheduleOnRuntime: global.__workletsModuleProxy.scheduleOnRuntime,
-      executeOnUIRuntimeSync:
-        global.__workletsModuleProxy.executeOnUIRuntimeSync,
-      createWorkletRuntime: global.__workletsModuleProxy.createWorkletRuntime,
-      makeShareableClone: global.__workletsModuleProxy.makeShareableClone,
-      makeShareableString: global.__workletsModuleProxy.makeShareableString,
-      makeShareableNumber: global.__workletsModuleProxy.makeShareableNumber,
-      makeShareableBoolean: global.__workletsModuleProxy.makeShareableBoolean,
-      makeShareableBigInt: global.__workletsModuleProxy.makeShareableBigInt,
-      makeShareableUndefined:
-        global.__workletsModuleProxy.makeShareableUndefined,
-      makeShareableNull: global.__workletsModuleProxy.makeShareableNull,
-    };
+    this.#workletsModuleProxy = global.__workletsModuleProxy;
     this.#shareableNull = this.#workletsModuleProxy.makeShareableNull();
     this.#shareableUndefined =
       this.#workletsModuleProxy.makeShareableUndefined();
@@ -64,6 +50,10 @@ See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooti
     );
   }
 
+  makeShareableImport<TValue>(from: string, to: string): ShareableRef<TValue> {
+    return this.#workletsModuleProxy.makeShareableImport(from, to);
+  }
+
   makeShareableString(str: string) {
     return this.#workletsModuleProxy.makeShareableString(str);
   }
@@ -88,6 +78,64 @@ See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooti
     return this.#shareableNull;
   }
 
+  makeShareableTurboModuleLike<TProps extends object, TProto extends object>(
+    props: TProps,
+    proto: TProto
+  ): ShareableRef<TProps> {
+    return this.#workletsModuleProxy.makeShareableTurboModuleLike(props, proto);
+  }
+
+  makeShareableObject<T extends object>(
+    obj: T,
+    shouldRetainRemote: boolean,
+    nativeStateSource?: object
+  ): ShareableRef<T> {
+    return this.#workletsModuleProxy.makeShareableObject(
+      obj,
+      shouldRetainRemote,
+      nativeStateSource
+    );
+  }
+
+  makeShareableHostObject<T extends object>(obj: T) {
+    return this.#workletsModuleProxy.makeShareableHostObject(obj);
+  }
+
+  makeShareableArray(array: unknown[], shouldRetainRemote: boolean) {
+    return this.#workletsModuleProxy.makeShareableArray(
+      array,
+      shouldRetainRemote
+    );
+  }
+
+  makeShareableMap<TKey, TValue>(
+    keys: TKey[],
+    values: TValue[]
+  ): ShareableRef<Map<TKey, TValue>> {
+    return this.#workletsModuleProxy.makeShareableMap(keys, values);
+  }
+
+  makeShareableSet<TValues>(values: TValues[]): ShareableRef<Set<TValues>> {
+    return this.#workletsModuleProxy.makeShareableSet(values);
+  }
+
+  makeShareableInitializer(obj: object) {
+    return this.#workletsModuleProxy.makeShareableInitializer(obj);
+  }
+
+  makeShareableFunction<TArgs extends unknown[], TReturn>(
+    func: (...args: TArgs) => TReturn
+  ) {
+    return this.#workletsModuleProxy.makeShareableFunction(func);
+  }
+
+  makeShareableWorklet(worklet: object, shouldPersistRemote: boolean) {
+    return this.#workletsModuleProxy.makeShareableWorklet(
+      worklet,
+      shouldPersistRemote
+    );
+  }
+
   scheduleOnUI<TValue>(shareable: ShareableRef<TValue>) {
     return this.#workletsModuleProxy.scheduleOnUI(shareable);
   }
@@ -111,4 +159,18 @@ See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooti
       shareableWorklet
     );
   }
+
+  reportFatalErrorOnJS(
+    message: string,
+    stack: string,
+    name: string,
+    jsEngine: string
+  ) {
+    return this.#workletsModuleProxy.reportFatalErrorOnJS(
+      message,
+      stack,
+      name,
+      jsEngine
+    );
+  }
 }

package/src/WorkletsModule/workletsModuleInstance.ts

@@ -1,9 +1,9 @@
 'use strict';
 
-import { shouldBeUseWeb } from '../PlatformChecker';
+import { SHOULD_BE_USE_WEB } from '../PlatformChecker';
 import { createJSWorkletsModule } from './JSWorklets';
 import { createNativeWorkletsModule } from './NativeWorklets';
 
-export const WorkletsModule = shouldBeUseWeb()
+export const WorkletsModule = SHOULD_BE_USE_WEB
   ? createJSWorkletsModule()
   : createNativeWorkletsModule();

package/src/WorkletsModule/workletsModuleProxy.ts

@@ -10,6 +10,11 @@ export interface WorkletsModuleProxy {
     nativeStateSource?: object
   ): ShareableRef<TValue>;
 
+  makeShareableImport<TValue>(
+    source: string,
+    imported: string
+  ): ShareableRef<TValue>;
+
   makeShareableString(str: string): ShareableRef<string>;
 
   makeShareableNumber(num: number): ShareableRef<number>;
@@ -22,6 +27,42 @@ export interface WorkletsModuleProxy {
 
   makeShareableNull(): ShareableRef<null>;
 
+  makeShareableTurboModuleLike<TProps extends object, TProto extends object>(
+    props: TProps,
+    proto: TProto
+  ): ShareableRef<TProps>;
+
+  makeShareableObject<T extends object>(
+    obj: T,
+    shouldRetainRemote: boolean,
+    nativeStateSource?: object
+  ): ShareableRef<T>;
+
+  makeShareableHostObject<T extends object>(obj: T): ShareableRef<T>;
+
+  makeShareableArray(
+    array: unknown[],
+    shouldRetainRemote: boolean
+  ): ShareableRef<unknown[]>;
+
+  makeShareableMap<TKey, TValue>(
+    keys: TKey[],
+    values: TValue[]
+  ): ShareableRef<Map<TKey, TValue>>;
+
+  makeShareableSet<TValues>(values: TValues[]): ShareableRef<Set<TValues>>;
+
+  makeShareableInitializer(obj: object): ShareableRef<object>;
+
+  makeShareableFunction<TArgs extends unknown[], TReturn>(
+    func: (...args: TArgs) => TReturn
+  ): ShareableRef<TReturn>;
+
+  makeShareableWorklet(
+    worklet: object,
+    shouldPersistRemote: boolean
+  ): ShareableRef<object>;
+
   scheduleOnUI<TValue>(shareable: ShareableRef<TValue>): void;
 
   executeOnUIRuntimeSync<TValue, TReturn>(
@@ -37,6 +78,13 @@ export interface WorkletsModuleProxy {
     workletRuntime: WorkletRuntime,
     worklet: ShareableRef<TValue>
   ): void;
+
+  reportFatalErrorOnJS(
+    message: string,
+    stack: string,
+    name: string,
+    jsEngine: string
+  ): void;
 }
 
-export interface IWorkletsModule extends WorkletsModuleProxy {}
+export type IWorkletsModule = WorkletsModuleProxy;

package/src/bundleUnpacker.ts

@@ -0,0 +1,75 @@
+'use strict';
+import { logger } from './logger';
+import { WorkletsError } from './WorkletsError';
+import type { WorkletFactory, WorkletFunction } from './workletTypes';
+
+const handleCache = new WeakMap<WorkletFunction, unknown>();
+
+export function bundleValueUnpacker(
+  objectToUnpack: ObjectToUnpack,
+  category?: string,
+  remoteFunctionName?: string
+): unknown {
+  const workletHash = objectToUnpack.__workletHash;
+  if (workletHash !== undefined) {
+    return getWorklet(workletHash, objectToUnpack.__closure);
+  } else if (objectToUnpack.__init !== undefined) {
+    let value = handleCache.get(objectToUnpack);
+    if (value === undefined) {
+      value = objectToUnpack.__init();
+      handleCache.set(objectToUnpack, value);
+    }
+    return value;
+  } else if (category === 'RemoteFunction') {
+    const remoteFunctionHolder = () => {
+      const label = remoteFunctionName
+        ? `function \`${remoteFunctionName}\``
+        : 'anonymous function';
+      throw new WorkletsError(`Tried to synchronously call a non-worklet ${label} on the UI thread.
+See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#tried-to-synchronously-call-a-non-worklet-function-on-the-ui-thread for more details.`);
+    };
+    remoteFunctionHolder.__remoteFunction = objectToUnpack;
+    return remoteFunctionHolder;
+  } else {
+    throw new WorkletsError(
+      `Data type in category "${category}" not recognized by value unpacker: "${globalThis._toString(
+        objectToUnpack
+      )}".`
+    );
+  }
+}
+
+function getWorklet(
+  workletHash: number,
+  closureVariables: Record<string, unknown>
+): WorkletFunction | undefined {
+  let worklet;
+  if (__DEV__) {
+    try {
+      worklet = getWorkletFromMetroRequire(workletHash, closureVariables);
+    } catch (_e) {
+      logger.error(
+        'Unable to resolve worklet with hash' +
+          workletHash +
+          'try to reload the app.'
+      );
+    }
+  } else {
+    worklet = getWorkletFromMetroRequire(workletHash, closureVariables);
+  }
+  return worklet;
+}
+
+const metroRequire = globalThis.__r;
+
+function getWorkletFromMetroRequire(
+  workletHash: number,
+  closureVariables: Record<string, unknown>
+): WorkletFunction {
+  const factory = metroRequire(workletHash).default as WorkletFactory;
+  return factory(closureVariables);
+}
+
+interface ObjectToUnpack extends WorkletFunction {
+  _recur: unknown;
+}

package/src/callGuard.ts

@@ -0,0 +1,33 @@
+'use strict';
+
+import type { RNError } from './errors';
+
+/** Used only with debug builds. */
+export function callGuardDEV<Args extends unknown[], ReturnValue>(
+  fn: (...args: Args) => ReturnValue,
+  ...args: Args
+): ReturnValue | void {
+  'worklet';
+  try {
+    return fn(...args);
+  } catch (error) {
+    if (globalThis.__workletsModuleProxy) {
+      const { message, stack, name, jsEngine } = error as RNError;
+      globalThis.__workletsModuleProxy.reportFatalErrorOnJS(
+        message,
+        stack ?? '',
+        name ?? 'WorkletsError',
+        jsEngine ?? 'Worklets'
+      );
+    } else {
+      throw error;
+    }
+  }
+}
+
+export function setupCallGuard() {
+  'worklet';
+  if (!globalThis.__callGuardDEV) {
+    globalThis.__callGuardDEV = callGuardDEV;
+  }
+}

package/src/errors.ts

@@ -1,5 +1,6 @@
 'use strict';
 
+import { WorkletsError } from './WorkletsError';
 import type { WorkletStackDetails } from './workletTypes';
 
 const _workletStackDetails = new Map<number, WorkletStackDetails>();
@@ -23,7 +24,10 @@ function getBundleOffset(error: Error): [string, number, number] {
   return ['unknown', 0, 0];
 }
 
-function processStack(stack: string): string {
+function processStack(stack?: string): string | undefined {
+  if (stack === '' || stack === undefined) {
+    return undefined;
+  }
   const workletStackEntries = stack.match(/worklet_(\d+):(\d+):(\d+)/g);
   let result = stack;
   workletStackEntries?.forEach((match) => {
@@ -42,22 +46,35 @@ function processStack(stack: string): string {
   return result;
 }
 
-export function reportFatalErrorOnJS({
-  message,
-  stack,
-  moduleName,
-}: {
-  message: string;
-  stack?: string;
-  moduleName: string;
-}) {
-  // eslint-disable-next-line reanimated/use-worklets-error
-  const error = new Error();
+export interface RNError extends Error {
+  jsEngine: string;
+}
+
+/**
+ * Remote error is an error coming from a Worklet Runtime that we bubble up to
+ * the RN Runtime.
+ */
+export function reportFatalRemoteError(
+  { message, stack, name, jsEngine }: RNError,
+  force: boolean
+): void {
+  const error = new WorkletsError() as RNError;
   error.message = message;
-  error.stack = stack ? processStack(stack) : undefined;
-  error.name = `${moduleName}Error`;
-  // @ts-ignore React Native's ErrorUtils implementation extends the Error type with jsEngine field
-  error.jsEngine = moduleName;
-  // @ts-ignore the reportFatalError method is an internal method of ErrorUtils not exposed in the type definitions
-  global.ErrorUtils.reportFatalError(error);
+  error.stack = processStack(stack);
+  error.name = name;
+  error.jsEngine = jsEngine;
+  if (force) {
+    throw error;
+  } else {
+    // @ts-expect-error React Native's `ErrorUtils` are hidden from the global scope.
+    globalThis.ErrorUtils.reportFatalError(error);
+  }
+}
+
+/**
+ * Registers `reportFatalRemoteError` function in global scope to allow to
+ * invoke it from C++.
+ */
+export function registerReportFatalRemoteError() {
+  globalThis.__reportFatalRemoteError = reportFatalRemoteError;
 }

package/src/index.ts

@@ -1,19 +1,12 @@
 'use strict';
 
-import { initializeUIRuntime } from './initializers';
-import { WorkletsModule } from './WorkletsModule';
+import './publicGlobals';
 
-// TODO: Specify the initialization pipeline since now there's no
-// universal source of truth for it.
-initializeUIRuntime(WorkletsModule);
+import { init } from './initializers';
+import { bundleModeInit } from './workletRuntimeEntry';
+
+init();
 
-export type { LoggerConfig } from './logger';
-export {
-  logger,
-  LogLevel,
-  registerLoggerConfig,
-  updateLoggerConfig,
-} from './logger';
 export { createWorkletRuntime, runOnRuntime } from './runtimes';
 export { shareableMappingCache } from './shareableMappingCache';
 export {
@@ -37,3 +30,10 @@ export type {
   WorkletRuntime,
   WorkletStackDetails,
 } from './workletTypes';
+
+// @ts-expect-error We must trick the bundler to include
+// the `workletRuntimeEntry` file the way it cannot optimize it out.
+if (globalThis._ALWAYS_FALSE) {
+  // Bundle mode.
+  bundleModeInit();
+}