@depup/react-native-worklets 0.12.2-depup.0 → 0.13.0-depup.0

package/src/networking/http.ts

@@ -0,0 +1,173 @@
+'use strict';
+
+const TOKEN_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const HEADER_VALUE_PATTERN = /^[^\0\r\n]*$/;
+const HTTP_WHITESPACE_PATTERN = /^[\t\n\r ]+|[\t\n\r ]+$/g;
+const ABSOLUTE_URL_SCHEME_PATTERN = /^([A-Za-z][A-Za-z0-9+\-.]*):/;
+const CHARSET_PARAMETER_PATTERN = /;\s*charset\s*=\s*("([^"]*)"|([^;\s]*))/i;
+
+const NORMALIZED_METHODS = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+const FORBIDDEN_METHODS = ['CONNECT', 'TRACE', 'TRACK'];
+const SUPPORTED_SCHEMES = ['http', 'https'];
+
+const FORBIDDEN_REQUEST_HEADERS = new Set([
+  'accept-charset',
+  'accept-encoding',
+  'access-control-request-headers',
+  'access-control-request-method',
+  'connection',
+  'content-length',
+  'cookie',
+  'cookie2',
+  'date',
+  'dnt',
+  'expect',
+  'host',
+  'keep-alive',
+  'origin',
+  'referer',
+  'set-cookie',
+  'te',
+  'trailer',
+  'transfer-encoding',
+  'upgrade',
+  'via',
+]);
+const FORBIDDEN_REQUEST_HEADER_PREFIXES = ['proxy-', 'sec-'];
+const METHOD_OVERRIDE_HEADERS = new Set([
+  'x-http-method',
+  'x-http-method-override',
+  'x-method-override',
+]);
+const FORBIDDEN_RESPONSE_HEADERS = new Set(['set-cookie', 'set-cookie2']);
+
+export function normalizeMethod(method: string): string {
+  const uppercasedMethod = method.toUpperCase();
+  return NORMALIZED_METHODS.includes(uppercasedMethod)
+    ? uppercasedMethod
+    : method;
+}
+
+export function isToken(value: string): boolean {
+  return TOKEN_PATTERN.test(value);
+}
+
+export function isForbiddenMethod(method: string): boolean {
+  return FORBIDDEN_METHODS.includes(method.toUpperCase());
+}
+
+export function isSupportedRequestUrl(url: string): boolean {
+  const scheme = ABSOLUTE_URL_SCHEME_PATTERN.exec(url)?.[1];
+  return (
+    scheme !== undefined && SUPPORTED_SCHEMES.includes(scheme.toLowerCase())
+  );
+}
+
+export function isHeaderName(name: string): boolean {
+  return isToken(name);
+}
+
+export function isHeaderValue(value: string): boolean {
+  return HEADER_VALUE_PATTERN.test(value);
+}
+
+export function normalizeHeaderValue(value: string): string {
+  return value.replace(HTTP_WHITESPACE_PATTERN, '');
+}
+
+export function isForbiddenRequestHeader(name: string, value: string): boolean {
+  const lowerCaseName = name.toLowerCase();
+  if (
+    FORBIDDEN_REQUEST_HEADERS.has(lowerCaseName) ||
+    FORBIDDEN_REQUEST_HEADER_PREFIXES.some((prefix) =>
+      lowerCaseName.startsWith(prefix)
+    )
+  ) {
+    return true;
+  }
+  return (
+    METHOD_OVERRIDE_HEADERS.has(lowerCaseName) &&
+    value.split(',').some((method) => isForbiddenMethod(method.trim()))
+  );
+}
+
+export function combineHeader(
+  headers: Array<[string, string]>,
+  name: string,
+  value: string
+) {
+  const lowerCaseName = name.toLowerCase();
+  const existing = headers.find(
+    ([headerName]) => headerName.toLowerCase() === lowerCaseName
+  );
+  if (existing === undefined) {
+    headers.push([name, value]);
+  } else {
+    existing[1] = `${existing[1]}, ${value}`;
+  }
+}
+
+export function hasHeader(
+  headers: Array<[string, string]>,
+  name: string
+): boolean {
+  const lowerCaseName = name.toLowerCase();
+  return headers.some(
+    ([headerName]) => headerName.toLowerCase() === lowerCaseName
+  );
+}
+
+export function getHeader(
+  headers: Array<[string, string]>,
+  name: string
+): string | null {
+  const lowerCaseName = name.toLowerCase();
+  if (FORBIDDEN_RESPONSE_HEADERS.has(lowerCaseName)) {
+    return null;
+  }
+  const values = headers
+    .filter(([headerName]) => headerName.toLowerCase() === lowerCaseName)
+    .map(([, value]) => value);
+  return values.length > 0 ? values.join(', ') : null;
+}
+
+export function sortAndCombineHeaders(
+  headers: Array<[string, string]>
+): string {
+  const combined = new Map<string, string[]>();
+  for (const [name, value] of headers) {
+    const lowerCaseName = name.toLowerCase();
+    if (FORBIDDEN_RESPONSE_HEADERS.has(lowerCaseName)) {
+      continue;
+    }
+    const values = combined.get(lowerCaseName);
+    if (values === undefined) {
+      combined.set(lowerCaseName, [value]);
+    } else {
+      values.push(value);
+    }
+  }
+  return Array.from(combined.keys())
+    .sort((left, right) => {
+      const uppercasedLeft = left.toUpperCase();
+      const uppercasedRight = right.toUpperCase();
+      if (uppercasedLeft === uppercasedRight) {
+        return 0;
+      }
+      return uppercasedLeft < uppercasedRight ? -1 : 1;
+    })
+    .map((name) => `${name}: ${combined.get(name)!.join(', ')}\r\n`)
+    .join('');
+}
+
+export function extractCharset(mimeType: string | null): string | undefined {
+  if (mimeType === null) {
+    return undefined;
+  }
+  const match = CHARSET_PARAMETER_PATTERN.exec(mimeType);
+  if (match === null) {
+    return undefined;
+  }
+  const charset = match[2] ?? match[3] ?? '';
+  return charset !== '' ? charset : undefined;
+}

package/src/networking/install.ts

@@ -0,0 +1,38 @@
+'use strict';
+
+import { AbortController, AbortSignal } from './AbortController';
+import { Blob } from './Blob';
+import { DOMException } from './DOMException';
+import { FileReader } from './FileReader';
+import { FormData } from './FormData';
+import { XMLHttpRequest } from './XMLHttpRequest';
+
+/**
+ * Installs the networking API (`fetch`, `XMLHttpRequest` and their supporting
+ * globals) on a Worklet Runtime. The native `__workletsNetworking` binding is
+ * installed by C++ only on Worklet Runtimes in Bundle Mode, so this function is
+ * a no-op anywhere else.
+ *
+ * All polyfills must be in place before `whatwg-fetch` is required because it
+ * feature-detects them at module scope.
+ */
+let installed = false;
+
+export function installNetworking() {
+  if (globalThis.__workletsNetworking === undefined || installed) {
+    return;
+  }
+  installed = true;
+
+  const global = globalThis as unknown as Record<string, unknown>;
+  global.XMLHttpRequest ??= XMLHttpRequest;
+  global.Blob ??= Blob;
+  global.FileReader ??= FileReader;
+  global.FormData ??= FormData;
+  global.DOMException ??= DOMException;
+  global.AbortController ??= AbortController;
+  global.AbortSignal ??= AbortSignal;
+
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require('whatwg-fetch');
+}

package/src/networking/utf8.ts

@@ -0,0 +1,122 @@
+/* eslint-disable no-bitwise */
+'use strict';
+
+type TextEncoderLike = new () => { encode: (value: string) => Uint8Array };
+
+export function utf8Encode(value: string): Uint8Array {
+  const TextEncoderConstructor = (
+    globalThis as { TextEncoder?: TextEncoderLike }
+  ).TextEncoder;
+  if (TextEncoderConstructor !== undefined) {
+    return new TextEncoderConstructor().encode(value);
+  }
+
+  const bytes: number[] = [];
+  for (let i = 0; i < value.length; i++) {
+    let codePoint = value.codePointAt(i)!;
+    if (codePoint > 0xffff) {
+      i++;
+    }
+    if (codePoint >= 0xd800 && codePoint <= 0xdfff) {
+      codePoint = 0xfffd;
+    }
+    if (codePoint < 0x80) {
+      bytes.push(codePoint);
+    } else if (codePoint < 0x800) {
+      bytes.push(0xc0 | (codePoint >> 6), 0x80 | (codePoint & 0x3f));
+    } else if (codePoint < 0x10000) {
+      bytes.push(
+        0xe0 | (codePoint >> 12),
+        0x80 | ((codePoint >> 6) & 0x3f),
+        0x80 | (codePoint & 0x3f)
+      );
+    } else {
+      bytes.push(
+        0xf0 | (codePoint >> 18),
+        0x80 | ((codePoint >> 12) & 0x3f),
+        0x80 | ((codePoint >> 6) & 0x3f),
+        0x80 | (codePoint & 0x3f)
+      );
+    }
+  }
+  return new Uint8Array(bytes);
+}
+
+export function utf8Decode(bytes: Uint8Array): string {
+  const codePoints: number[] = [];
+  let codePoint = 0;
+  let bytesNeeded = 0;
+  let bytesSeen = 0;
+  let lowerBoundary = 0x80;
+  let upperBoundary = 0xbf;
+  let index = 0;
+  while (index < bytes.length) {
+    const byte = bytes[index];
+    if (bytesNeeded === 0) {
+      index++;
+      if (byte <= 0x7f) {
+        codePoints.push(byte);
+      } else if (byte >= 0xc2 && byte <= 0xdf) {
+        bytesNeeded = 1;
+        codePoint = byte & 0x1f;
+      } else if (byte >= 0xe0 && byte <= 0xef) {
+        lowerBoundary = byte === 0xe0 ? 0xa0 : 0x80;
+        upperBoundary = byte === 0xed ? 0x9f : 0xbf;
+        bytesNeeded = 2;
+        codePoint = byte & 0x0f;
+      } else if (byte >= 0xf0 && byte <= 0xf4) {
+        lowerBoundary = byte === 0xf0 ? 0x90 : 0x80;
+        upperBoundary = byte === 0xf4 ? 0x8f : 0xbf;
+        bytesNeeded = 3;
+        codePoint = byte & 0x07;
+      } else {
+        codePoints.push(0xfffd);
+      }
+      continue;
+    }
+    if (byte < lowerBoundary || byte > upperBoundary) {
+      codePoint = 0;
+      bytesNeeded = 0;
+      bytesSeen = 0;
+      lowerBoundary = 0x80;
+      upperBoundary = 0xbf;
+      codePoints.push(0xfffd);
+      continue;
+    }
+    lowerBoundary = 0x80;
+    upperBoundary = 0xbf;
+    codePoint = (codePoint << 6) | (byte & 0x3f);
+    bytesSeen++;
+    index++;
+    if (bytesSeen === bytesNeeded) {
+      codePoints.push(codePoint);
+      codePoint = 0;
+      bytesNeeded = 0;
+      bytesSeen = 0;
+    }
+  }
+  if (bytesNeeded !== 0) {
+    codePoints.push(0xfffd);
+  }
+
+  let result = '';
+  const chunkSize = 4096;
+  for (let offset = 0; offset < codePoints.length; offset += chunkSize) {
+    result += String.fromCodePoint(
+      ...codePoints.slice(offset, offset + chunkSize)
+    );
+  }
+  return result;
+}
+
+export function stripUtf8Bom(bytes: Uint8Array): Uint8Array {
+  if (
+    bytes.length >= 3 &&
+    bytes[0] === 0xef &&
+    bytes[1] === 0xbb &&
+    bytes[2] === 0xbf
+  ) {
+    return bytes.subarray(3);
+  }
+  return bytes;
+}

package/src/privateGlobals.d.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
 'use strict';
 
 // This file works by accident - currently Builder Bob doesn't move `.d.ts` files to output types.
@@ -57,14 +56,12 @@ declare global {
   var _createSerializableArray: (
     value: unknown[]
   ) => FlatSerializableRef<unknown[]>;
-  var _createSerializableInitializer: (
-    value: object
-  ) => FlatSerializableRef<object>;
   var _createSerializableSynchronizable: (
     value: object
   ) => FlatShareableRef<object>;
   var __serializer: typeof makeShareableCloneOnUIRecursive;
-  var __callMicrotasks: () => void;
+  /** Available on runtimes with the Hermes microtask queue enabled. */
+  var __drainMicrotasks: () => void;
   /** Available only on the UI Runtime */
   var __nativeRequestAnimationFrame: (
     callback: (timestamp: number) => void
@@ -93,12 +90,6 @@ declare global {
     runtime: WorkletRuntime,
     worklet: SerializableRef<() => void>
   ) => void;
-  /**
-   * @deprecated Kept for backwards compatibility. Remove it after support for
-   *   Reanimated 4.3 is dropped. Reanimated uses it to handle event updates
-   *   synchronously.
-   */
-  var _microtaskQueueFinalizers: (() => void)[];
   var _scheduleTimeoutCallback: (delay: number, handlerId: number) => void;
   var __runTimeoutCallback: (handlerId: number) => void;
   var _taskQueue: Queue;
@@ -112,14 +103,30 @@ declare global {
     unknown,
     unknown
   >;
-  /** Only in Bundle Mode on Worklet Runtimes. */
-  var TurboModules: Map<string, unknown>;
   /**
    * Native logging hook installed by React Native on the RN Runtime and
    * propagated to Worklet Runtimes in Bundle Mode. Level values match RN's
    * `LOG_LEVELS`: 0 = trace, 1 = info, 2 = warn, 3 = error.
    */
   var nativeLoggingHook: ((message: string, level: number) => void) | undefined;
+  /** Only in Bundle Mode on Worklet Runtimes. */
+  var __workletsNetworking:
+    | {
+        sendRequest(
+          config: {
+            method: string;
+            url: string;
+            headers: Array<[string, string]>;
+            body?: string | ArrayBuffer;
+            timeoutMs: number;
+            withCredentials: boolean;
+          },
+          onEvent: (type: string, payload: unknown) => void
+        ): number;
+        abortRequest(requestId: number): void;
+        decodeText(buffer: ArrayBuffer, encoding?: string): string;
+      }
+    | undefined;
   interface NodeRequire {
     resolveWeak(id: string): number;
     getModules(): Map<number, unknown>;

package/src/runLoop/common/queueMicrotaskPolyfill.ts

@@ -0,0 +1,12 @@
+'use strict';
+
+// See https://github.com/facebook/hermes/blob/829dcd74f5b774d19a86ab1dc47e3dee9e44d190/lib/VM/JSLib/HermesInternal.cpp#L421-L432.
+type IHermesInternal = typeof HermesInternal & {
+  enqueueJob: (job: () => void) => void;
+};
+export function setupQueueMicrotask() {
+  'worklet';
+  globalThis.queueMicrotask = (
+    (globalThis as Record<string, unknown>).HermesInternal as IHermesInternal
+  ).enqueueJob;
+}

package/src/runLoop/uiRuntime/requestAnimationFrame.ts

@@ -21,14 +21,17 @@ export function setupRequestAnimationFrame() {
     flushedCallbacksEnd = queuedCallbacksEnd;
     queuedCallbacksBegin = queuedCallbacksEnd;
 
-    for (const callback of flushedCallbacks) {
-      callback(timestamp);
+    if (flushedCallbacks.length > 0) {
+      for (const callback of flushedCallbacks) {
+        callback(timestamp);
+        globalThis.__drainMicrotasks();
+      }
+    } else {
+      globalThis.__drainMicrotasks();
     }
 
     flushedCallbacksBegin = flushedCallbacksEnd;
 
-    globalThis.__callMicrotasks();
-
     const finalizers = queuedFinalizers;
     queuedFinalizers = [];
     for (const finalizer of finalizers) {

package/src/runLoop/workletRuntime/index.ts

@@ -1,8 +1,8 @@
 'use strict';
 
+import { setupQueueMicrotask } from '../common/queueMicrotaskPolyfill';
 import { setupSetImmediate } from '../common/setImmediatePolyfill';
 import { setupSetInterval } from '../common/setIntervalPolyfill';
-import { setupQueueMicrotask } from './queueMicrotask';
 import { setupRequestAnimationFrame } from './requestAnimationFramePolyfill';
 import { setupSetTimeout } from './setTimeout';
 import { setupTaskQueue } from './taskQueue';

package/src/runLoop/workletRuntime/requestAnimationFramePolyfill.ts

@@ -27,7 +27,7 @@ export function setupRequestAnimationFrame(animationQueuePollingRate: number) {
 
     for (const callback of flushedCallbacks) {
       callback(timestamp);
-      globalThis.__callMicrotasks();
+      globalThis.__drainMicrotasks();
     }
 
     flushedCallbacksBegin = flushedCallbacksEnd;

package/src/runLoop/workletRuntime/taskQueue.ts

@@ -3,14 +3,12 @@
 type Callback = () => void;
 
 export type Queue = {
-  microtasks: Array<Callback>;
   timeoutCallbacks: Map<number, Callback>;
 };
 
 export function setupTaskQueue() {
   'worklet';
   const queue: Queue = {
-    microtasks: [],
     timeoutCallbacks: new Map(),
   };
   globalThis._taskQueue = queue;
@@ -20,19 +18,6 @@ export function setupTaskQueue() {
     task?.();
     queue.timeoutCallbacks.delete(handlerId);
   };
-
-  globalThis.__callMicrotasks = function callMicrotasks() {
-    for (let i = 0; i < queue.microtasks.length; i++) {
-      queue.microtasks[i]();
-    }
-    queue.microtasks = [];
-  };
-}
-
-export function pushMicrotask(callback: Callback) {
-  'worklet';
-  const queue = globalThis._taskQueue;
-  queue.microtasks.push(callback);
 }
 
 export function pushTask(callback: Callback, handlerId: number, delay: number) {

package/src/runtimes.native.ts

@@ -82,6 +82,7 @@ export function createWorkletRuntime(
   let animationQueuePollingRate: number;
   let enableEventLoop = true;
   let enableLocking = true;
+  let enableNetworking = true;
   if (typeof nameOrConfig === 'string') {
     name = nameOrConfig;
     initializerFn = initializer;
@@ -106,6 +107,13 @@ export function createWorkletRuntime(
     enableEventLoop = enableLocking
       ? (nameOrConfig?.enableEventLoop ?? true)
       : false;
+    /**
+     * The networking API depends on the Event Loop - `whatwg-fetch` resolves
+     * its responses through `setTimeout`. Without it, requests would hang
+     * instead of failing visibly.
+     */
+    enableNetworking =
+      (nameOrConfig?.enableNetworking ?? true) && enableEventLoop;
   }
 
   const useDefaultQueue = queue === 'default';
@@ -136,7 +144,8 @@ export function createWorkletRuntime(
     useDefaultQueue,
     customQueue,
     enableEventLoop,
-    enableLocking
+    enableLocking,
+    enableNetworking
   );
 }
 

package/src/specs/NativeWorkletsModule.ts

@@ -4,6 +4,7 @@ import { type TurboModule, TurboModuleRegistry } from 'react-native';
 
 export interface Spec extends TurboModule {
   installTurboModule: (bundleModeEnabled: boolean) => boolean;
+  prepareBundleMode: () => boolean;
   toggleSlowAnimationsOnUIRuntime: () => boolean;
   start: () => boolean;
 }

package/src/threads.native.ts

@@ -19,42 +19,36 @@ const SHOULD_CAPTURE_SCHEDULE_STACK =
 type UIJob<Args extends unknown[] = unknown[], ReturnValue = unknown> = [
   worklet: WorkletFunction<Args, ReturnValue>,
   args: Args,
-  resolve: ((value: ReturnValue) => void) | undefined,
+  resolve:
+    | ((value: ReturnValue | PromiseLike<ReturnValue>) => void)
+    | undefined,
   reject: ((reason: unknown) => void) | undefined,
   scheduleStack: string | undefined,
 ];
 
 let runOnUIQueue: UIJob[] = [];
 
-export function setupMicrotasks() {
+function runAsyncUIJob<Args extends unknown[], ReturnValue>(
+  workletFunction: WorkletFunction<Args, ReturnValue>,
+  workletArgs: Args,
+  resolve: (value: ReturnValue | PromiseLike<ReturnValue>) => void,
+  reject: (reason: unknown) => void
+): void {
   'worklet';
-
-  let microtasksQueue: Array<() => void> = [];
-  let isExecutingMicrotasksQueue = false;
-  globalThis.queueMicrotask = (callback: () => void) => {
-    microtasksQueue.push(callback);
-  };
-  // TODO: Remove it after support for Reanimated 4.3 is dropped.
-  globalThis._microtaskQueueFinalizers = [];
-
-  globalThis.__callMicrotasks = () => {
-    if (isExecutingMicrotasksQueue) {
-      return;
-    }
-    try {
-      isExecutingMicrotasksQueue = true;
-      for (let index = 0; index < microtasksQueue.length; index += 1) {
-        // we use classic 'for' loop because the size of the currentTasks array may change while executing some of the callbacks due to queueMicrotask calls
-        microtasksQueue[index]();
-      }
-      microtasksQueue = [];
-      globalThis._microtaskQueueFinalizers.forEach((finalizer) => finalizer());
-    } finally {
-      isExecutingMicrotasksQueue = false;
-    }
-  };
+  try {
+    const result = workletFunction(...workletArgs);
+    const serializedResult = globalThis.__serializer(
+      result
+    ) as SerializableRef<ReturnValue>;
+    globalThis.__workletsModuleProxy.handlePromise(resolve, serializedResult);
+  } catch (error) {
+    const serializedError = globalThis.__serializer(error);
+    globalThis.__workletsModuleProxy.handlePromise(reject, serializedError);
+  }
 }
 
+let serializableRunAsyncUIJob: SerializableRef | undefined;
+
 /**
  * Lets you schedule a function to be executed on the [UI
  * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds#ui-runtime).
@@ -341,7 +335,7 @@ export function runOnUIAsync<Args extends unknown[], ReturnValue>(
 function enqueueUI<Args extends unknown[], ReturnValue>(
   worklet: WorkletFunction<Args, ReturnValue>,
   args: Args,
-  resolve?: (value: ReturnValue) => void,
+  resolve?: (value: ReturnValue | PromiseLike<ReturnValue>) => void,
   reject?: (reason: unknown) => void
 ): void {
   const scheduleStack = SHOULD_CAPTURE_SCHEDULE_STACK
@@ -361,42 +355,43 @@ function flushUIQueue(): void {
   queueMicrotask(() => {
     const queue = runOnUIQueue;
     runOnUIQueue = [];
-    const jobWorklets = queue.map(
-      ([workletFunction, workletArgs, resolve, reject]) =>
-        createSerializable(() => {
-          'worklet';
-          try {
-            const result = workletFunction(...workletArgs);
-            if (resolve) {
-              const serializedResult = globalThis.__serializer(result);
-              globalThis.__workletsModuleProxy.handlePromise(
-                resolve,
-                serializedResult
-              );
-            }
-          } catch (error) {
-            if (reject) {
-              const serializedError = globalThis.__serializer(error);
-              globalThis.__workletsModuleProxy.handlePromise(
-                reject,
-                serializedError
-              );
-            } else {
-              throw error;
-            }
-          }
-        })
-    );
+    const jobWorklets: SerializableRef[] = [];
+    const jobArguments: SerializableRef<unknown[]>[] = [];
+    for (const [workletFunction, workletArgs, resolve, reject] of queue) {
+      if (resolve === undefined) {
+        jobWorklets.push(createSerializable(workletFunction));
+        jobArguments.push(createSerializable(workletArgs));
+      } else {
+        serializableRunAsyncUIJob ??= createSerializable(runAsyncUIJob);
+        jobWorklets.push(serializableRunAsyncUIJob);
+        jobArguments.push(
+          createSerializable([workletFunction, workletArgs, resolve, reject!])
+        );
+      }
+    }
     const scheduleStacks = SHOULD_CAPTURE_SCHEDULE_STACK
       ? (queue.map(([, , , , scheduleStack]) => scheduleStack) as string[])
       : undefined;
     WorkletsModule.scheduleOnUI(
       WorkletsModule.createSerializableArray(jobWorklets),
+      WorkletsModule.createSerializableArray(jobArguments),
       scheduleStacks
     );
   });
 }
 
+/**
+ * Returns the id of the thread which currently executes JavaScript on the
+ * calling Runtime.
+ *
+ * @returns The id of the current thread.
+ * @see https://docs.swmansion.com/react-native-worklets/docs/utility/getCurrentThreadId
+ */
+export function getCurrentThreadId(): string {
+  'worklet';
+  return globalThis.__workletsModuleProxy.getCurrentThreadId();
+}
+
 if (__DEV__ && !isBundleModeEnabled()) {
   /**
    * QoL guards to give a meaningful error message when the user tries to call

package/src/threads.ts

@@ -120,3 +120,14 @@ function drainUIQueue(queue: UIJob[]): void {
     }
   }
 }
+
+/**
+ * Returns the id of the thread which currently executes JavaScript on the
+ * calling Runtime.
+ *
+ * @returns The id of the current thread.
+ * @see https://docs.swmansion.com/react-native-worklets/docs/utility/getCurrentThreadId
+ */
+export function getCurrentThreadId(): string {
+  throw new Error('[Worklets] `getCurrentThreadId` is not supported on web.');
+}