@amazon-devices/react-native-worklets 1.0.1 → 1.0.2

package/src/runLoop/uiRuntime/setTimeoutPolyfill.ts

@@ -1,40 +0,0 @@
-'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

@@ -1,18 +0,0 @@
-'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

@@ -1,13 +0,0 @@
-'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

@@ -1,61 +0,0 @@
-'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.__flushMicrotasks();
-    }
-
-    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] = () => {};
-    }
-  };
-}

package/src/runLoop/workletRuntime/setTimeout.ts

@@ -1,37 +0,0 @@
-'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;
-}

package/src/runLoop/workletRuntime/taskQueue.ts

@@ -1,44 +0,0 @@
-'use strict';
-
-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;
-
-  globalThis.__runTimeoutCallback = function (handlerId: number) {
-    const task = queue.timeoutCallbacks.get(handlerId);
-    task?.();
-    queue.timeoutCallbacks.delete(handlerId);
-    globalThis.__flushMicrotasks();
-  };
-
-  globalThis.__flushMicrotasks = function () {
-    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) {
-  'worklet';
-  const queue = globalThis._taskQueue;
-  queue.timeoutCallbacks.set(handlerId, callback);
-  globalThis._scheduleTimeoutCallback(delay, handlerId);
-}

package/src/runtimeKind.ts

@@ -1,37 +0,0 @@
-'use strict';
-
-export enum RuntimeKind {
-  /**
-   * The React Native runtime, which is the main runtime for React Native where
-   * React exists and where components are rendered.
-   */
-  ReactNative = 1,
-  /**
-   * The UI runtime, which is a special runtime that executes on the UI thread,
-   * mostly used for animations and gestures.
-   */
-  UI = 2,
-  /** Additional runtime created on-demand by the user. */
-  Worker = 3,
-}
-
-/**
- * Programmatic way to check the current runtime kind. It's useful when you need
- * specific implementations for different runtimes created by Worklets.
- *
- * For more optimized calls you can check the value of
- * `globalThis.__RUNTIME_KIND` directly.
- *
- * @returns The kind of the current runtime.
- */
-export function getRuntimeKind(): RuntimeKind {
-  'worklet';
-  return globalThis.__RUNTIME_KIND;
-}
-
-if (globalThis.__RUNTIME_KIND === undefined) {
-  // In Jest environments eager imports make this file to evaluate before
-  // `initializers.ts` file, therefore we have to set the RuntimeKind here,
-  // just to be safe.
-  globalThis.__RUNTIME_KIND = RuntimeKind.ReactNative;
-}

package/src/runtimes.ts

@@ -1,193 +0,0 @@
-'use strict';
-
-import { setupCallGuard } from './callGuard';
-import { getMemorySafeCapturableConsole, setupConsole } from './initializers';
-import { SHOULD_BE_USE_WEB } from './PlatformChecker';
-import { setupRunLoop } from './runLoop/workletRuntime';
-import { RuntimeKind } from './runtimeKind';
-import {
-  createSerializable,
-  makeShareableCloneOnUIRecursive,
-} from './serializable';
-import { isWorkletFunction } from './workletFunction';
-import { registerWorkletsError, WorkletsError } from './WorkletsError';
-import { WorkletsModule } from './WorkletsModule';
-import type { WorkletFunction, WorkletRuntime } from './workletTypes';
-
-/**
- * Lets you create a new JS runtime which can be used to run worklets possibly
- * on different threads than JS or UI thread.
- *
- * @param config - Runtime configuration object - {@link WorkletRuntimeConfig}.
- * @returns WorkletRuntime which is a
- *   `jsi::HostObject<worklets::WorkletRuntime>` - {@link WorkletRuntime}
- * @see https://docs.swmansion.com/react-native-worklets/docs/threading/createWorkletRuntime/
- */
-// @ts-expect-error Public API overload.
-export function createWorkletRuntime(
-  config?: WorkletRuntimeConfig
-): WorkletRuntime;
-
-/**
- * @deprecated Please use the new config object signature instead:
- *   `createWorkletRuntime({ name, initializer })`
- *
- *   Lets you create a new JS runtime which can be used to run worklets possibly
- *   on different threads than JS or UI thread.
- * @param name - A name used to identify the runtime which will appear in
- *   devices list in Chrome DevTools.
- * @param initializer - An optional worklet that will be run synchronously on
- *   the same thread immediately after the runtime is created.
- * @returns WorkletRuntime which is a
- *   `jsi::HostObject<worklets::WorkletRuntime>` - {@link WorkletRuntime}
- * @see https://docs.swmansion.com/react-native-worklets/docs/threading/createWorkletRuntime/
- */
-export function createWorkletRuntime(
-  name?: string,
-  initializer?: () => void
-): WorkletRuntime;
-
-export function createWorkletRuntime(
-  nameOrConfig?: string | WorkletRuntimeConfigInternal,
-  initializer?: WorkletFunction<[], void>
-): WorkletRuntime {
-  const runtimeBoundCapturableConsole = getMemorySafeCapturableConsole();
-
-  let name: string;
-  let initializerFn: (() => void) | undefined;
-  let useDefaultQueue = true;
-  let customQueue: object | undefined;
-  let animationQueuePollingRate: number;
-  let enableEventLoop = true;
-  if (typeof nameOrConfig === 'string') {
-    name = nameOrConfig;
-    initializerFn = initializer;
-  } else {
-    // TODO: Make anonymous name globally unique.
-    name = nameOrConfig?.name ?? 'anonymous';
-    initializerFn = nameOrConfig?.initializer;
-    useDefaultQueue = nameOrConfig?.useDefaultQueue ?? true;
-    customQueue = nameOrConfig?.customQueue;
-    animationQueuePollingRate = Math.round(
-      nameOrConfig?.animationQueuePollingRate ?? 16
-    );
-    enableEventLoop = nameOrConfig?.enableEventLoop ?? true;
-  }
-
-  if (initializerFn && !isWorkletFunction(initializerFn)) {
-    throw new WorkletsError(
-      'The initializer passed to `createWorkletRuntime` is not a worklet.'
-    );
-  }
-
-  return WorkletsModule.createWorkletRuntime(
-    name,
-    createSerializable(() => {
-      'worklet';
-      setupCallGuard();
-      registerWorkletsError();
-      setupConsole(runtimeBoundCapturableConsole);
-      if (enableEventLoop) {
-        setupRunLoop(animationQueuePollingRate);
-      }
-      initializerFn?.();
-    }),
-    useDefaultQueue,
-    customQueue,
-    enableEventLoop
-  );
-}
-
-// @ts-expect-error Check `runOnUI` overload.
-export function runOnRuntime<Args extends unknown[], ReturnValue>(
-  workletRuntime: WorkletRuntime,
-  worklet: (...args: Args) => ReturnValue
-): WorkletFunction<Args, ReturnValue>;
-/** Schedule a worklet to execute on the background queue. */
-export function runOnRuntime<Args extends unknown[], ReturnValue>(
-  workletRuntime: WorkletRuntime,
-  worklet: WorkletFunction<Args, ReturnValue>
-): (...args: Args) => void {
-  'worklet';
-  if (__DEV__ && !SHOULD_BE_USE_WEB && !isWorkletFunction(worklet)) {
-    throw new WorkletsError(
-      'The function passed to `runOnRuntime` is not a worklet.'
-    );
-  }
-  if (globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
-    return (...args) =>
-      globalThis._scheduleOnRuntime(
-        workletRuntime,
-        makeShareableCloneOnUIRecursive(() => {
-          'worklet';
-          worklet(...args);
-        })
-      );
-  }
-  return (...args) =>
-    WorkletsModule.scheduleOnRuntime(
-      workletRuntime,
-      createSerializable(() => {
-        'worklet';
-        worklet(...args);
-        globalThis.__flushMicrotasks();
-      })
-    );
-}
-
-/** Configuration object for creating a worklet runtime. */
-export type WorkletRuntimeConfig = {
-  /** The name of the worklet runtime. */
-  name?: string;
-  /**
-   * A worklet that will be run immediately after the runtime is created and
-   * before any other worklets.
-   */
-  initializer?: () => void;
-  /**
-   * Time interval in milliseconds between polling of frame callbacks scheduled
-   * by requestAnimationFrame. If not specified, it defaults to 16 ms.
-   */
-  animationQueuePollingRate?: number;
-  /**
-   * Determines whether to enable the default Event Loop or not. The Event Loop
-   * provides implementations for `setTimeout`, `setImmediate`, `setInterval`,
-   * `requestAnimationFrame`, `queueMicrotask`, `clearTimeout`, `clearInterval`,
-   * `clearImmediate`, and `cancelAnimationFrame` methods. If not specified, it
-   * defaults to `true`.
-   */
-  enableEventLoop?: true;
-} & (
-  | {
-      /**
-       * If true, the runtime will use the default queue implementation for
-       * scheduling worklets. Defaults to true.
-       */
-      useDefaultQueue?: true;
-      /**
-       * An optional custom queue to be used for scheduling worklets.
-       *
-       * The queue has to implement the C++ `AsyncQueue` interface from
-       * `<worklets/Public/AsyncQueue.h>`.
-       */
-      customQueue?: never;
-    }
-  | {
-      /**
-       * If true, the runtime will use the default queue implementation for
-       * scheduling worklets. Defaults to true.
-       */
-      useDefaultQueue: false;
-      /**
-       * An optional custom queue to be used for scheduling worklets.
-       *
-       * The queue has to implement the C++ `AsyncQueue` interface from
-       * `<worklets/Public/AsyncQueue.h>`.
-       */
-      customQueue?: object;
-    }
-);
-
-type WorkletRuntimeConfigInternal = WorkletRuntimeConfig & {
-  initializer?: WorkletFunction<[], void>;
-};