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

package/src/memory/valueUnpacker.native.ts

@@ -0,0 +1,79 @@
+'use strict';
+
+import type { ValueUnpacker, WorkletFunction } from '../types';
+
+declare global {
+  var evalWithSourceMap:
+    | ((js: string, sourceURL: string, sourceMap: string) => () => unknown)
+    | undefined;
+  var evalWithSourceUrl:
+    | ((js: string, sourceURL: string) => () => unknown)
+    | undefined;
+  var evalBytecode: ((bytecode: ArrayBuffer) => () => unknown) | undefined;
+}
+
+export function installValueUnpacker() {
+  'worklet';
+  'no-worklet-closure';
+  const workletsCache = new Map<number, () => unknown>();
+  const handleCache = new WeakMap<object, unknown>();
+
+  function valueUnpacker(objectToUnpack: ObjectToUnpack): unknown {
+    const workletHash = objectToUnpack.__workletHash;
+    if (workletHash !== undefined) {
+      let workletFun = workletsCache.get(workletHash);
+      if (workletFun === undefined) {
+        const initData = objectToUnpack.__initData;
+        if (initData!.bytecode !== undefined) {
+          workletFun = globalThis.evalBytecode!(initData!.bytecode);
+        } else if (globalThis.evalWithSourceMap && initData!.sourceMap) {
+          // 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!,
+            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!,
+            `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!);
+        }
+        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 {
+      throw new Error(
+        `[Worklets] Data type not recognized by value unpacker: "${globalThis._toString(
+          objectToUnpack
+        )}".`
+      );
+    }
+  }
+
+  globalThis.__valueUnpacker = valueUnpacker as ValueUnpacker;
+}
+
+interface ObjectToUnpack extends WorkletFunction {
+  _recur: unknown;
+}

package/src/mock.ts

@@ -0,0 +1,111 @@
+'use strict';
+
+import { mockedRequestAnimationFrame } from './runLoop/uiRuntime/mockedRequestAnimationFrame';
+import { RuntimeKind } from './runtimeKind';
+import { isWorkletFunction } from './workletFunction';
+
+const NOOP = () => {};
+const NOOP_FACTORY = () => NOOP;
+const ID = <TValue>(value: TValue) => value;
+const IMMEDIATE_CALLBACK_INVOCATION = <TCallback>(callback: () => TCallback) =>
+  callback();
+
+globalThis._WORKLET = false;
+globalThis.__RUNTIME_KIND = RuntimeKind.ReactNative;
+globalThis._log = console.log;
+globalThis._getAnimationTimestamp = () => performance.now();
+// requestAnimationFrame react-native jest's setup is incorrect as it polyfills
+// the method directly using setTimeout, therefore the callback doesn't get the
+// expected timestamp as the only argument.
+// We override this setup here to make sure that callbacks get the proper timestamps
+// when executed. For non-jest environments we define requestAnimationFrame in setupRequestAnimationFrame
+// @ts-ignore TypeScript uses Node definition for rAF, setTimeout, etc which returns a Timeout object rather than a number
+globalThis.requestAnimationFrame = mockedRequestAnimationFrame;
+
+const WorkletAPI = {
+  isShareableRef: () => true,
+  makeShareable: ID,
+  makeShareableCloneOnUIRecursive: ID,
+  makeShareableCloneRecursive: ID,
+  shareableMappingCache: new Map(),
+  getStaticFeatureFlag: () => false,
+  setDynamicFeatureFlag: NOOP,
+  isSynchronizable: () => false,
+  getRuntimeKind: () => RuntimeKind.ReactNative,
+  RuntimeKind: RuntimeKind,
+  createWorkletRuntime: NOOP_FACTORY,
+  runOnRuntime: ID,
+  runOnRuntimeAsync<Args extends unknown[], ReturnValue>(
+    _workletRuntime: unknown,
+    worklet: (...args: Args) => ReturnValue,
+    ...args: Args
+  ): Promise<ReturnValue> {
+    return WorkletAPI.runOnUIAsync(worklet, ...args);
+  },
+  scheduleOnRuntime: IMMEDIATE_CALLBACK_INVOCATION,
+  createSerializable: ID,
+  isSerializableRef: ID,
+  serializableMappingCache: new Map(),
+  createSynchronizable: ID,
+  callMicrotasks: NOOP,
+  executeOnUIRuntimeSync: ID,
+  runOnJS<Args extends unknown[], ReturnValue>(
+    fun: (...args: Args) => ReturnValue
+  ): (...args: Args) => void {
+    return (...args) =>
+      queueMicrotask(
+        args.length
+          ? () => (fun as (...args: Args) => ReturnValue)(...args)
+          : (fun as () => ReturnValue)
+      );
+  },
+  runOnUI<Args extends unknown[], ReturnValue>(
+    worklet: (...args: Args) => ReturnValue
+  ): (...args: Args) => void {
+    return (...args) => {
+      // Mocking time in Jest is tricky as both requestAnimationFrame and queueMicrotask
+      // callbacks run on the same queue and can be interleaved. There is no way
+      // to flush particular queue in Jest and the only control over mocked timers
+      // is by using jest.advanceTimersByTime() method which advances all types
+      // of timers including immediate and animation callbacks. Ideally we'd like
+      // to have some way here to schedule work along with React updates, but
+      // that's not possible, and hence in Jest environment instead of using scheduling
+      // mechanism we just schedule the work ommiting the queue. This is ok for the
+      // uses that we currently have but may not be ok for future tests that we write.
+      mockedRequestAnimationFrame(() => {
+        worklet(...args);
+      });
+    };
+  },
+  runOnUIAsync<Args extends unknown[], ReturnValue>(
+    worklet: (...args: Args) => ReturnValue,
+    ...args: Args
+  ): Promise<ReturnValue> {
+    return new Promise<ReturnValue>((resolve) => {
+      mockedRequestAnimationFrame(() => {
+        const result = worklet(...args);
+        resolve(result);
+      });
+    });
+  },
+  runOnUISync: IMMEDIATE_CALLBACK_INVOCATION,
+  scheduleOnRN<Args extends unknown[], ReturnValue>(
+    fun: (...args: Args) => ReturnValue,
+    ...args: Args
+  ): void {
+    WorkletAPI.runOnJS(fun)(...args);
+  },
+  scheduleOnUI<Args extends unknown[], ReturnValue>(
+    worklet: (...args: Args) => ReturnValue,
+    ...args: Args
+  ): void {
+    WorkletAPI.runOnUI(worklet)(...args);
+  },
+  isWorkletFunction: isWorkletFunction,
+  WorkletsModule: {},
+};
+
+module.exports = {
+  __esModule: true,
+  ...WorkletAPI,
+};

package/src/platformChecker.native.ts

@@ -0,0 +1,3 @@
+'use strict';
+
+export const IS_JEST = false;

package/src/platformChecker.ts

@@ -0,0 +1,4 @@
+'use strict';
+
+export const IS_JEST: boolean =
+  typeof globalThis.jest !== 'undefined' || process.env.NODE_ENV === 'test';

package/src/privateGlobals.d.ts

@@ -0,0 +1,127 @@
+/* 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.
+// If it ever breaks, we should address it so we'd not pollute the user's global namespace.
+import type { reportFatalRemoteError } from './debug/errors';
+import type { CustomSerializableUnpacker } from './memory/customSerializableUnpacker';
+import type { RemoteFunctionUnpacker } from './memory/remoteFunctionUnpacker';
+import type { makeShareableCloneOnUIRecursive } from './memory/serializable';
+import type { ShareableGuestUnpacker } from './memory/shareableGuestUnpacker';
+import type { ShareableHostUnpacker } from './memory/shareableHostUnpacker';
+import type { SynchronizableUnpacker } from './memory/synchronizableUnpacker';
+import type { CustomSerializationRegistry } from './memory/types';
+import type { Queue } from './runLoop/workletRuntime/taskQueue';
+import type { ValueUnpacker } from './types';
+import type { WorkletsModuleProxy } from './WorkletsModule/workletsModuleProxy';
+
+declare global {
+  /** The only runtime-available require method is `__r` defined by Metro. */
+  var __r: ((moduleId: number) => Record<string, unknown>) &
+    Record<string, unknown>;
+
+  /**
+   * The name of the current runtime, used in debugging.
+   *
+   * - "RN" for the RN Runtime.
+   * - "UI" for the UI Runtime.
+   * - A custom name for Worker Runtimes.
+   */
+  var __RUNTIME_NAME: string;
+
+  var _toString: (value: unknown) => string;
+  var __workletsModuleProxy: WorkletsModuleProxy;
+  var _WORKLETS_BUNDLE_MODE_ENABLED: boolean | undefined;
+  var _WORKLETS_VERSION_CPP: string | undefined;
+  var _WORKLETS_VERSION_JS: string | undefined;
+  var _createSerializableString: (value: string) => FlatSerializableRef<string>;
+  var _createSerializableNumber: (value: number) => FlatSerializableRef<number>;
+  var _createSerializableBoolean: (
+    value: boolean
+  ) => FlatSerializableRef<boolean>;
+  var _createSerializableBigInt: (value: bigint) => FlatSerializableRef<bigint>;
+  var _createSerializableUndefined: () => FlatSerializableRef<undefined>;
+  var _createSerializableNull: () => FlatSerializableRef<null>;
+  var _createSerializableObject: <T extends object>(
+    value: T,
+    shouldRetainRemote: boolean,
+    nativeStateSource?: object
+  ) => FlatSerializableRef<T>;
+  var _createSerializableHostObject: <T extends object>(
+    value: T
+  ) => FlatSerializableRef<T>;
+  var _createSerializableWorklet: (
+    value: object,
+    shouldPersistRemote: boolean
+  ) => FlatSerializableRef<object>;
+  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 only on the UI Runtime */
+  var __nativeRequestAnimationFrame: (
+    callback: (timestamp: number) => void
+  ) => void;
+  /** Available only on RN Runtime */
+  var __reportFatalRemoteError: typeof reportFatalRemoteError | undefined;
+  var __valueUnpacker: ValueUnpacker;
+  var __synchronizableUnpacker: SynchronizableUnpacker;
+  var __customSerializationRegistry: CustomSerializationRegistry;
+  var __customSerializableUnpacker: CustomSerializableUnpacker;
+  var __remoteFunctionUnpacker: RemoteFunctionUnpacker;
+  /**
+   * @deprecated Kept for backwards compatibility. Remove it after support for
+   *   Reanimated 4.3 is dropped. Reanimated uses it to handle event updates
+   *   synchronously.
+   */
+  var __flushAnimationFrame: (timestamp: number) => void;
+  var __frameTimestamp: number | undefined;
+  var _log: (value: unknown) => void;
+  var _startProfiling: (meanHzFreq?: number) => void;
+  var _stopProfiling: () => string;
+  var _beginSection: (name: string) => void;
+  var _endSection: () => void;
+  var _getAnimationTimestamp: () => number;
+  var _scheduleOnRuntime: (
+    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;
+  /** Only in Debug builds. */
+  var __hasNativeState: (value: object) => boolean;
+  /** Only in Debug builds. */
+  var __isHostObject: (value: object) => boolean;
+  var __shareableHostUnpacker: ShareableHostUnpacker<unknown, unknown, unknown>;
+  var __shareableGuestUnpacker: ShareableGuestUnpacker<
+    unknown,
+    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;
+  interface NodeRequire {
+    resolveWeak(id: string): number;
+    getModules(): Map<number, unknown>;
+  }
+}

package/src/runLoop/common/setImmediatePolyfill.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+export function setupSetImmediate() {
+  'worklet';
+
+  const setImmediatePolyfill = (
+    callback: (...args: unknown[]) => void,
+    ...args: unknown[]
+  ) => {
+    return setTimeout(callback, 0, ...args);
+  };
+
+  const clearImmediatePolyfill = (immediateHandle: number) => {
+    clearTimeout(immediateHandle);
+  };
+
+  globalThis.setImmediate =
+    setImmediatePolyfill as unknown as typeof setImmediate;
+  globalThis.clearImmediate = clearImmediatePolyfill as typeof clearImmediate;
+}

package/src/runLoop/common/setIntervalPolyfill.ts

@@ -0,0 +1,38 @@
+'use strict';
+
+export function setupSetInterval() {
+  'worklet';
+
+  const intervalHandleToTimeoutHandle: Map<number, number> = new Map();
+
+  const setIntervalPolyfill = (
+    callback: (...args: unknown[]) => void,
+    delay: number = 0,
+    ...args: unknown[]
+  ) => {
+    let intervalHandle = 0;
+
+    const repeatingCallback = () => {
+      const timeoutHandle = setTimeout(
+        repeatingCallback,
+        delay
+      ) as unknown as number;
+      intervalHandleToTimeoutHandle.set(intervalHandle, timeoutHandle);
+      callback(...args);
+    };
+
+    intervalHandle = setTimeout(repeatingCallback, delay) as unknown as number;
+    intervalHandleToTimeoutHandle.set(intervalHandle, intervalHandle);
+
+    return intervalHandle;
+  };
+
+  const clearIntervalPolyfill = (intervalHandle: number) => {
+    const timeoutHandle = intervalHandleToTimeoutHandle.get(intervalHandle);
+    clearTimeout(timeoutHandle);
+    intervalHandleToTimeoutHandle.delete(intervalHandle);
+  };
+
+  globalThis.setInterval = setIntervalPolyfill as typeof setInterval;
+  globalThis.clearInterval = clearIntervalPolyfill as typeof clearInterval;
+}

package/src/runLoop/uiRuntime/mockedRequestAnimationFrame.ts

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * This is Jest implementation of `requestAnimationFrame` that is required by
+ * React Native for test purposes.
+ */
+export function mockedRequestAnimationFrame(
+  callback: (timestamp: number) => void
+): ReturnType<typeof setTimeout> {
+  return setTimeout(() => callback(performance.now()), 0);
+}

package/src/runLoop/uiRuntime/requestAnimationFrame.ts

@@ -0,0 +1,87 @@
+'use strict';
+
+export function setupRequestAnimationFrame() {
+  'worklet';
+  const callMicrotasks = globalThis.__callMicrotasks;
+
+  let queuedCallbacks: ((timestamp: number) => void)[] = [];
+  let queuedCallbacksBegin = 0;
+  let queuedCallbacksEnd = 0;
+
+  let flushedCallbacks = queuedCallbacks;
+  let flushedCallbacksBegin = 0;
+  let flushedCallbacksEnd = 0;
+
+  let queuedFinalizers: (() => void)[] = [];
+
+  function executeQueue(timestamp: number) {
+    flushedCallbacks = queuedCallbacks;
+    queuedCallbacks = [];
+
+    flushedCallbacksBegin = queuedCallbacksBegin;
+    flushedCallbacksEnd = queuedCallbacksEnd;
+    queuedCallbacksBegin = queuedCallbacksEnd;
+
+    for (const callback of flushedCallbacks) {
+      callback(timestamp);
+    }
+
+    flushedCallbacksBegin = flushedCallbacksEnd;
+
+    callMicrotasks();
+
+    const finalizers = queuedFinalizers;
+    queuedFinalizers = [];
+    for (const finalizer of finalizers) {
+      finalizer();
+    }
+  }
+
+  function requestAnimationFrame(
+    callback: (timestamp: number) => void
+  ): number {
+    const handle = queuedCallbacksEnd++;
+    queuedCallbacks.push(callback);
+    return handle;
+  }
+
+  function cancelAnimationFrame(handle: number) {
+    if (handle < flushedCallbacksBegin || handle >= queuedCallbacksEnd) {
+      return;
+    }
+
+    if (handle < flushedCallbacksEnd) {
+      flushedCallbacks[handle - flushedCallbacksBegin] = () => {};
+    } else {
+      queuedCallbacks[handle - queuedCallbacksBegin] = () => {};
+    }
+  }
+
+  function nativeFlushQueue(timestamp: number) {
+    flushQueue(timestamp);
+
+    /* Schedule next frame */
+    globalThis.__nativeRequestAnimationFrame(nativeFlushQueue);
+  }
+
+  function flushQueue(timestamp: number) {
+    globalThis.__frameTimestamp = timestamp;
+    executeQueue(timestamp);
+    globalThis.__frameTimestamp = undefined;
+  }
+
+  globalThis.requestAnimationFrame = requestAnimationFrame;
+  globalThis.cancelAnimationFrame =
+    cancelAnimationFrame as typeof globalThis.cancelAnimationFrame;
+  globalThis.requestAnimationFrameFinalizer = (callback: () => void) => {
+    queuedFinalizers.push(callback);
+  };
+
+  /* Start the loop */
+  globalThis.__nativeRequestAnimationFrame(nativeFlushQueue);
+
+  // TODO: Remove it after support for Reanimated 4.3 is dropped.
+  globalThis.__flushAnimationFrame = (eventTimestamp: number) => {
+    flushQueue(eventTimestamp);
+  };
+}

package/src/runLoop/uiRuntime/setTimeoutPolyfill.ts

@@ -0,0 +1,40 @@
+'use strict';
+
+export function setupSetTimeout() {
+  'worklet';
+
+  const timeoutHandleToRafHandle: Map<number, number> = new Map();
+
+  const setTimeoutPolyfill = (
+    callback: (...args: unknown[]) => void,
+    delay: number = 0,
+    ...args: unknown[]
+  ) => {
+    const start = performance.now();
+    let timeoutHandle = 0;
+
+    const rafCallback = () => {
+      const now = performance.now();
+      if (now - start >= delay) {
+        callback(...args);
+        timeoutHandleToRafHandle.delete(timeoutHandle);
+      } else {
+        const rafHandle = requestAnimationFrame(rafCallback);
+        timeoutHandleToRafHandle.set(timeoutHandle, rafHandle);
+      }
+    };
+
+    timeoutHandle = requestAnimationFrame(rafCallback);
+    timeoutHandleToRafHandle.set(timeoutHandle, timeoutHandle);
+    return timeoutHandle;
+  };
+
+  const clearTimeoutPolyfill = (timeoutHandle: number) => {
+    const rafHandle = timeoutHandleToRafHandle.get(timeoutHandle);
+    timeoutHandleToRafHandle.delete(timeoutHandle);
+    cancelAnimationFrame(rafHandle);
+  };
+
+  globalThis.setTimeout = setTimeoutPolyfill as typeof setTimeout;
+  globalThis.clearTimeout = clearTimeoutPolyfill as typeof clearTimeout;
+}

package/src/runLoop/workletRuntime/index.ts

@@ -0,0 +1,18 @@
+'use strict';
+
+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';
+
+export function setupRunLoop(animationQueuePollingRate: number) {
+  'worklet';
+  setupTaskQueue();
+  setupQueueMicrotask();
+  setupSetTimeout();
+  setupRequestAnimationFrame(animationQueuePollingRate);
+  setupSetImmediate();
+  setupSetInterval();
+}

package/src/runLoop/workletRuntime/queueMicrotask.ts

@@ -0,0 +1,13 @@
+'use strict';
+
+import { pushMicrotask } from './taskQueue';
+
+export function setupQueueMicrotask() {
+  'worklet';
+  globalThis.queueMicrotask = function (
+    callback: (...args: unknown[]) => void,
+    ...args: unknown[]
+  ) {
+    pushMicrotask(() => callback(...args));
+  } as typeof queueMicrotask;
+}

package/src/runLoop/workletRuntime/requestAnimationFramePolyfill.ts

@@ -0,0 +1,61 @@
+'use strict';
+
+export function setupRequestAnimationFrame(animationQueuePollingRate: number) {
+  'worklet';
+  const timeoutInterval = animationQueuePollingRate;
+
+  let queuedCallbacks: ((timestamp: number) => void)[] = [];
+  let queuedCallbacksBegin = 0;
+  let queuedCallbacksEnd = 0;
+
+  let flushedCallbacks = queuedCallbacks;
+  let flushedCallbacksBegin = 0;
+  let flushedCallbacksEnd = 0;
+
+  let flushRequested = false;
+
+  function flushAnimationFrame() {
+    flushRequested = false;
+    const timestamp = performance.now();
+
+    flushedCallbacks = queuedCallbacks;
+    queuedCallbacks = [];
+
+    flushedCallbacksBegin = queuedCallbacksBegin;
+    flushedCallbacksEnd = queuedCallbacksEnd;
+    queuedCallbacksBegin = queuedCallbacksEnd;
+
+    for (const callback of flushedCallbacks) {
+      callback(timestamp);
+      globalThis.__callMicrotasks();
+    }
+
+    flushedCallbacksBegin = flushedCallbacksEnd;
+  }
+
+  globalThis.requestAnimationFrame = (
+    callback: (timestamp: number) => void
+  ): number => {
+    const handle = queuedCallbacksEnd++;
+
+    queuedCallbacks.push(callback);
+    if (!flushRequested) {
+      flushRequested = true;
+
+      setTimeout(flushAnimationFrame, timeoutInterval);
+    }
+    return handle;
+  };
+
+  globalThis.cancelAnimationFrame = ((handle: number) => {
+    if (handle < flushedCallbacksBegin || handle >= queuedCallbacksEnd) {
+      return;
+    }
+
+    if (handle < flushedCallbacksEnd) {
+      flushedCallbacks[handle - flushedCallbacksBegin] = () => {};
+    } else {
+      queuedCallbacks[handle - queuedCallbacksBegin] = () => {};
+    }
+  }) as typeof globalThis.cancelAnimationFrame;
+}

package/src/runLoop/workletRuntime/setTimeout.ts

@@ -0,0 +1,37 @@
+'use strict';
+
+import { pushTask } from './taskQueue';
+
+export function setupSetTimeout() {
+  'worklet';
+
+  const pendingHandlers: Set<number> = new Set();
+  let ID = 0;
+
+  const setTimeoutPolyfill = (
+    callback: (...args: unknown[]) => void,
+    delay: number = 0,
+    ...args: unknown[]
+  ) => {
+    const handlerId = ID++;
+
+    const timeoutCallback = () => {
+      if (!pendingHandlers.has(handlerId)) {
+        return;
+      }
+      callback(...args);
+      pendingHandlers.delete(handlerId);
+    };
+
+    pendingHandlers.add(handlerId);
+    pushTask(timeoutCallback, handlerId, delay);
+    return handlerId;
+  };
+
+  const clearTimeoutPolyfill = (timeoutHandle: number) => {
+    pendingHandlers.delete(timeoutHandle);
+  };
+
+  globalThis.setTimeout = setTimeoutPolyfill as typeof setTimeout;
+  globalThis.clearTimeout = clearTimeoutPolyfill as typeof clearTimeout;
+}