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

package/src/valueUnpacker.ts

@@ -0,0 +1,90 @@
+'use strict';
+import type { ValueUnpacker, WorkletFunction } from './workletTypes';
+
+declare global {
+  var evalWithSourceMap:
+    | ((js: string, sourceURL: string, sourceMap: string) => () => unknown)
+    | undefined;
+  var evalWithSourceUrl:
+    | ((js: string, sourceURL: string) => () => unknown)
+    | undefined;
+}
+
+function __installUnpacker() {
+  const workletsCache = new Map<number, () => unknown>();
+  const handleCache = new WeakMap<object, unknown>();
+
+  function valueUnpacker(
+    objectToUnpack: ObjectToUnpack,
+    category?: string,
+    remoteFunctionName?: string
+  ): unknown {
+    'use strict';
+    const workletHash = objectToUnpack.__workletHash;
+    if (workletHash !== undefined) {
+      let workletFun = workletsCache.get(workletHash);
+      if (workletFun === undefined) {
+        const initData = objectToUnpack.__initData;
+        if (globalThis.evalWithSourceMap) {
+          // if the runtime (hermes only for now) supports loading source maps
+          // we want to use the proper filename for the location as it guarantees
+          // that debugger understands and loads the source code of the file where
+          // the worklet is defined.
+          workletFun = globalThis.evalWithSourceMap(
+            '(' + initData!.code + '\n)',
+            initData!.location!,
+            initData!.sourceMap!
+          );
+        } else if (globalThis.evalWithSourceUrl) {
+          // if the runtime doesn't support loading source maps, in dev mode we
+          // can pass source url when evaluating the worklet. Now, instead of using
+          // the actual file location we use worklet hash, as it the allows us to
+          // properly symbolicate traces (see errors.ts for details)
+          workletFun = globalThis.evalWithSourceUrl(
+            '(' + initData!.code + '\n)',
+            `worklet_${workletHash}`
+          );
+        } else {
+          // in release we use the regular eval to save on JSI calls
+          // eslint-disable-next-line no-eval
+          workletFun = eval('(' + initData!.code + '\n)');
+        }
+        workletsCache.set(workletHash, workletFun!);
+      }
+      const functionInstance = workletFun!.bind(objectToUnpack);
+      objectToUnpack._recur = functionInstance;
+      return functionInstance;
+    } 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 fun = () => {
+        const label = remoteFunctionName
+          ? `function \`${remoteFunctionName}\``
+          : 'anonymous function';
+        // eslint-disable-next-line reanimated/use-worklets-error
+        throw new Error(`[Worklets] 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.`);
+      };
+      fun.__remoteFunction = objectToUnpack;
+      return fun;
+    } else {
+      // eslint-disable-next-line reanimated/use-worklets-error
+      throw new Error(
+        `[Worklets] Data type in category "${category}" not recognized by value unpacker: "${globalThis._toString(
+          objectToUnpack
+        )}".`
+      );
+    }
+  }
+
+  globalThis.__valueUnpacker = valueUnpacker as ValueUnpacker;
+}
+
+interface ObjectToUnpack extends WorkletFunction {
+  _recur: unknown;
+}

package/src/workletFunction.ts

@@ -0,0 +1,42 @@
+'use strict';
+
+import type { WorkletFunction } from './workletTypes';
+
+/**
+ * This function allows you to determine if a given function is a worklet. It
+ * only works with Reanimated Babel plugin enabled. Unless you are doing
+ * something with internals of Reanimated you shouldn't need to use this
+ * function.
+ *
+ * ### Note
+ *
+ * Do not call it before the worklet is declared, as it will always return false
+ * then. E.g.:
+ *
+ * ```ts
+ * isWorkletFunction(myWorklet); // Will always return false.
+ *
+ * function myWorklet() {
+ *   'worklet';
+ * }
+ * ```
+ *
+ * ### Maintainer note
+ *
+ * This function is supposed to be used only in the React Runtime. It always
+ * returns `false` in Worklet Runtimes.
+ */
+export function isWorkletFunction<
+  Args extends unknown[] = unknown[],
+  ReturnValue = unknown,
+>(value: unknown): value is WorkletFunction<Args, ReturnValue> {
+  'worklet';
+  // Since host objects always return true for `in` operator, we have to use dot notation to check if the property exists.
+  // See https://github.com/facebook/hermes/blob/340726ef8cf666a7cce75bc60b02fa56b3e54560/lib/VM/JSObject.cpp#L1276.
+
+  return (
+    // `__workletHash` isn't extracted in Worklet Runtimes.
+    typeof value === 'function' &&
+    !!(value as unknown as Record<string, unknown>).__workletHash
+  );
+}

package/src/workletRuntimeEntry.ts

@@ -0,0 +1,35 @@
+'use strict';
+
+import { init } from './initializers';
+import { SHOULD_BE_USE_WEB } from './PlatformChecker';
+import { RuntimeKind } from './runtimeKind';
+import { WorkletsError } from './WorkletsError';
+
+/**
+ * This function is an entry point for Worklet Runtimes. We can use it to setup
+ * necessary tools, like the ValueUnpacker.
+ *
+ * We must throw an error at the end of this function to prevent the bundle to
+ * continue executing. This is because the next module to be ran would be the
+ * React Native one, and it would break the Worklet Runtime if initialized. The
+ * error is caught in C++ code.
+ *
+ * This function has no effect on the RN Runtime beside setting the
+ * `_WORKLETS_BUNDLE_MODE` flag.
+ */
+export function bundleModeInit() {
+  globalThis._WORKLETS_BUNDLE_MODE = true;
+  if (
+    !SHOULD_BE_USE_WEB &&
+    globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative
+  ) {
+    /**
+     * We shouldn't call `init()` on RN Runtime here, as it would initialize our
+     * module before React Native has configured the RN Runtime.
+     */
+    init();
+    throw new WorkletsError('Worklets initialized successfully');
+  }
+}
+
+bundleModeInit();

package/src/workletTypes.ts

@@ -0,0 +1,81 @@
+'use strict';
+
+/**
+ * The below type is used for HostObjects returned by the JSI API that don't
+ * have any accessible fields or methods but can carry data that is accessed
+ * from the c++ side. We add a field to the type to make it possible for
+ * typescript to recognize which JSI methods accept those types as arguments and
+ * to be able to correctly type check other methods that may use them. However,
+ * this field is not actually defined nor should be used for anything else as
+ * assigning any data to those objects will throw an error.
+ */
+export type SerializableRef<T = unknown> = {
+  __serializableRef: true;
+  __nativeStateSerializableJSRef: T;
+};
+
+// In case of objects with depth or arrays of objects or arrays of arrays etc.
+// we add this utility type that makes it a `SharaebleRef` of the outermost type.
+export type FlatSerializableRef<T> =
+  T extends SerializableRef<infer U> ? SerializableRef<U> : SerializableRef<T>;
+
+export type WorkletRuntime = {
+  __hostObjectWorkletRuntime: never;
+  readonly name: string;
+};
+
+export type WorkletStackDetails = [
+  error: Error,
+  lineOffset: number,
+  columnOffset: number,
+];
+
+export type WorkletClosure = Record<string, unknown>;
+
+interface WorkletInitData {
+  code: string;
+  /** Only in dev builds. */
+  location?: string;
+  /** Only in dev builds. */
+  sourceMap?: string;
+}
+
+interface WorkletProps {
+  __closure: WorkletClosure;
+  __workletHash: number;
+  /** Only in Legacy Bundling. */
+  __initData?: WorkletInitData;
+  /** Only for Handles. */
+  __init?: () => unknown;
+  /** `__stackDetails` is removed after parsing. */
+  __stackDetails?: WorkletStackDetails;
+  /** Only in dev builds. */
+  __pluginVersion?: string;
+}
+
+export type WorkletFunction<
+  TArgs extends unknown[] = unknown[],
+  TReturn = unknown,
+> = ((...args: TArgs) => TReturn) & WorkletProps;
+
+export interface WorkletFactory<
+  TArgs extends unknown[] = unknown[],
+  TReturn = unknown,
+  TClosureVariables extends Record<string, unknown> = Record<string, unknown>,
+> {
+  (closureVariables: TClosureVariables): WorkletFunction<TArgs, TReturn>;
+}
+
+export type ValueUnpacker = WorkletFunction<
+  [objectToUnpack: unknown, category?: string],
+  unknown
+>;
+
+export interface WorkletImport {
+  __bundleData: {
+    /** Name of the module which is the source of the import. */
+    source: string;
+    /** The name of the imported value. */
+    imported: string;
+  };
+}