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

package/src/callGuard.ts

@@ -1,33 +0,0 @@
-'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/deprecated.ts

@@ -1,32 +0,0 @@
-'use strict';
-
-import {
-  createSerializable,
-  isSerializableRef,
-  makeShareable,
-  makeShareableCloneOnUIRecursive,
-} from './serializable';
-import { serializableMappingCache } from './serializableMappingCache';
-import type { SerializableRef } from './workletTypes';
-
-/** @deprecated Use {@link SerializableRef} instead. */
-export type ShareableRef<T> = SerializableRef<T>;
-
-export { makeShareable, makeShareableCloneOnUIRecursive };
-
-/** @deprecated It will be removed in the next major version. */
-export type MakeShareableClone = <T>(
-  value: T,
-  shouldPersistRemote?: boolean,
-  depth?: number
-) => ShareableRef<T>;
-
-/** @deprecated Use {@link createSerializable} instead. */
-export const makeShareableCloneRecursive: MakeShareableClone =
-  createSerializable;
-
-/** @deprecated Use {@link isSerializableRef} instead. */
-export const isShareableRef = isSerializableRef;
-
-/** @deprecated Use {@link serializableMappingCache} instead. */
-export const shareableMappingCache = serializableMappingCache;

package/src/errors.ts

@@ -1,80 +0,0 @@
-'use strict';
-
-import { WorkletsError } from './WorkletsError';
-import type { WorkletStackDetails } from './workletTypes';
-
-const _workletStackDetails = new Map<number, WorkletStackDetails>();
-
-export function registerWorkletStackDetails(
-  hash: number,
-  stackDetails: WorkletStackDetails
-) {
-  _workletStackDetails.set(hash, stackDetails);
-}
-
-function getBundleOffset(error: Error): [string, number, number] {
-  const frame = error.stack?.split('\n')?.[0];
-  if (frame) {
-    const parsedFrame = /@([^@]+):(\d+):(\d+)/.exec(frame);
-    if (parsedFrame) {
-      const [, file, line, col] = parsedFrame;
-      return [file, Number(line), Number(col)];
-    }
-  }
-  return ['unknown', 0, 0];
-}
-
-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) => {
-    const [, hash, origLine, origCol] = match.split(/:|_/).map(Number);
-    const errorDetails = _workletStackDetails.get(hash);
-    if (!errorDetails) {
-      return;
-    }
-    const [error, lineOffset, colOffset] = errorDetails;
-    const [bundleFile, bundleLine, bundleCol] = getBundleOffset(error);
-    const line = origLine + bundleLine + lineOffset;
-    const col = origCol + bundleCol + colOffset;
-
-    result = result.replace(match, `${bundleFile}:${line}:${col}`);
-  });
-  return result;
-}
-
-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 = 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/featureFlags/index.ts

@@ -1,72 +0,0 @@
-'use strict';
-import { logger } from '../logger';
-import { WorkletsModule } from '../WorkletsModule';
-import type StaticFeatureFlagsJSON from './staticFlags.json';
-
-type DynamicFlagsType = {
-  EXAMPLE_DYNAMIC_FLAG: boolean;
-  init(): void;
-  setFlag(name: DynamicFlagName, value: boolean): void;
-};
-type DynamicFlagName = keyof Omit<Omit<DynamicFlagsType, 'setFlag'>, 'init'>;
-
-export const DynamicFlags: DynamicFlagsType = {
-  EXAMPLE_DYNAMIC_FLAG: true,
-
-  init() {
-    Object.keys(DynamicFlags).forEach((key) => {
-      if (key !== 'init' && key !== 'setFlag') {
-        WorkletsModule.setDynamicFeatureFlag(
-          key,
-          DynamicFlags[key as DynamicFlagName]
-        );
-      }
-    });
-  },
-  setFlag(name, value) {
-    if (name in DynamicFlags) {
-      DynamicFlags[name] = value;
-      WorkletsModule.setDynamicFeatureFlag(name, value);
-    } else {
-      logger.warn(
-        `The feature flag: '${name}' no longer exists, you can safely remove invocation of \`setDynamicFeatureFlag('${name}')\` from your code.`
-      );
-    }
-  },
-};
-DynamicFlags.init();
-// Public API function to update a feature flag
-export function setDynamicFeatureFlag(
-  name: DynamicFlagName,
-  value: boolean
-): void {
-  DynamicFlags.setFlag(name, value);
-}
-
-/**
- * This constant is needed for typechecking and preserving static typechecks in
- * generated .d.ts files. Without it, the static flags resolve to an object
- * without specific keys.
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const DefaultStaticFeatureFlags = {
-  RUNTIME_TEST_FLAG: false,
-  IOS_DYNAMIC_FRAMERATE_ENABLED: false,
-} as const satisfies typeof StaticFeatureFlagsJSON;
-
-type StaticFeatureFlagsSchema = {
-  -readonly [K in keyof typeof DefaultStaticFeatureFlags]: boolean;
-};
-
-const staticFeatureFlags: Partial<StaticFeatureFlagsSchema> = {};
-
-export function getStaticFeatureFlag(
-  name: keyof StaticFeatureFlagsSchema
-): boolean {
-  if (name in staticFeatureFlags) {
-    return staticFeatureFlags[name]!;
-  }
-  const featureFlagValue = WorkletsModule.getStaticFeatureFlag(name);
-  staticFeatureFlags[name] = featureFlagValue;
-  return featureFlagValue;
-}

package/src/initializers.ts

@@ -1,262 +0,0 @@
-'use strict';
-
-import { bundleValueUnpacker } from './bundleUnpacker';
-import { setupCallGuard } from './callGuard';
-import { registerReportFatalRemoteError } from './errors';
-import { IS_JEST, SHOULD_BE_USE_WEB } from './PlatformChecker';
-import { setupSetImmediate } from './runLoop/common/setImmediatePolyfill';
-import { setupSetInterval } from './runLoop/common/setIntervalPolyfill';
-import { mockedRequestAnimationFrame } from './runLoop/uiRuntime/mockedRequestAnimationFrame';
-import { setupRequestAnimationFrame } from './runLoop/uiRuntime/requestAnimationFrame';
-import { setupSetTimeout } from './runLoop/uiRuntime/setTimeoutPolyfill';
-import { RuntimeKind } from './runtimeKind';
-import { __installUnpacker as installSynchronizableUnpacker } from './synchronizableUnpacker';
-import { executeOnUIRuntimeSync, runOnJS, setupMicrotasks } from './threads';
-import { isWorkletFunction } from './workletFunction';
-import { registerWorkletsError, WorkletsError } from './WorkletsError';
-import { WorkletsModule } from './WorkletsModule';
-import type { ValueUnpacker } from './workletTypes';
-
-let capturableConsole: typeof console;
-
-/**
- * Currently there seems to be a bug in the JSI layer which causes a crash when
- * we try to copy some of the console methods, i.e. `clear` or `dirxml`.
- *
- * The crash happens only in React Native 0.75. It's not reproducible in neither
- * 0.76 nor 0.74. It also happens only in the configuration of a debug app and
- * production bundle.
- *
- * I haven't yet discovered what exactly causes the crash. It's tied to the
- * console methods sometimes being `HostFunction`s. Therefore, as a workaround
- * we don't copy the methods as they are in the original console object, we copy
- * JavaScript wrappers instead.
- */
-export function getMemorySafeCapturableConsole(): typeof console {
-  if (capturableConsole) {
-    return capturableConsole;
-  }
-
-  const consoleCopy = Object.fromEntries(
-    Object.entries(console).map(([methodName, method]) => {
-      const methodWrapper = function methodWrapper(...args: unknown[]) {
-        return method(...args);
-      };
-      if (method.name) {
-        /**
-         * Set the original method name as the wrapper name if available.
-         *
-         * It might be unnecessary but if we want to fully mimic the console
-         * object we should take into the account the fact some code might rely
-         * on the method name.
-         */
-        Object.defineProperty(methodWrapper, 'name', {
-          value: method.name,
-          writable: false,
-        });
-      }
-      return [methodName, methodWrapper];
-    })
-  );
-
-  capturableConsole = consoleCopy as unknown as typeof console;
-
-  return consoleCopy as unknown as typeof console;
-}
-
-export function setupConsole(boundCapturableConsole: typeof console) {
-  'worklet';
-  // @ts-ignore TypeScript doesn't like that there are missing methods in console object, but we don't provide all the methods for the UI runtime console version
-  globalThis.console = {
-    assert: runOnJS(boundCapturableConsole.assert),
-    debug: runOnJS(boundCapturableConsole.debug),
-    log: runOnJS(boundCapturableConsole.log),
-    warn: runOnJS(boundCapturableConsole.warn),
-    error: runOnJS(boundCapturableConsole.error),
-    info: runOnJS(boundCapturableConsole.info),
-  };
-}
-
-let initialized = false;
-
-export function init() {
-  if (initialized) {
-    return;
-  }
-  initialized = true;
-
-  if (globalThis.__RUNTIME_KIND === undefined) {
-    // The only runtime that doesn't have `__RUNTIME_KIND` preconfigured
-    // is the RN Runtime. We must set it as soon as possible.
-    globalThis.__RUNTIME_KIND = RuntimeKind.ReactNative;
-  }
-
-  initializeRuntime();
-
-  if (SHOULD_BE_USE_WEB) {
-    initializeRuntimeOnWeb();
-  }
-
-  if (globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
-    initializeWorkletRuntime();
-  } else {
-    initializeRNRuntime();
-    if (!SHOULD_BE_USE_WEB) {
-      installRNBindingsOnUIRuntime();
-    }
-  }
-}
-
-/** A function that should be run on any kind of runtime. */
-function initializeRuntime() {
-  if (globalThis._WORKLETS_BUNDLE_MODE) {
-    globalThis.__valueUnpacker = bundleValueUnpacker as ValueUnpacker;
-  }
-  installSynchronizableUnpacker();
-}
-
-/** A function that should be run only on React Native runtime. */
-function initializeRNRuntime() {
-  if (__DEV__) {
-    const testWorklet = () => {
-      'worklet';
-    };
-    if (!isWorkletFunction(testWorklet)) {
-      throw new WorkletsError(
-        `Failed to create a worklet. See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#failed-to-create-a-worklet for more details.`
-      );
-    }
-  }
-
-  registerReportFatalRemoteError();
-}
-
-/** A function that should be run only on Worklet runtimes. */
-function initializeWorkletRuntime() {
-  if (globalThis._WORKLETS_BUNDLE_MODE) {
-    setupCallGuard();
-
-    if (__DEV__) {
-      /*
-       * Temporary workaround for Metro bundler. We must implement a dummy
-       * Refresh module to prevent Metro from throwing irrelevant errors.
-       */
-      const Refresh = new Proxy(
-        {},
-        {
-          get() {
-            return () => {};
-          },
-        }
-      );
-
-      globalThis.__r.Refresh = Refresh;
-
-      /* Gracefully handle unwanted imports from React Native. */
-      // @ts-expect-error type not exposed by Metro
-      const modules = require.getModules();
-      // @ts-expect-error type not exposed by Metro
-      const ReactNativeModuleId = require.resolveWeak('react-native');
-
-      const factory = function (
-        _global: unknown,
-        _require: unknown,
-        _importDefault: unknown,
-        _importAll: unknown,
-        module: Record<string, unknown>,
-        _exports: unknown,
-        _dependencyMap: unknown
-      ) {
-        module.exports = new Proxy(
-          {},
-          {
-            get: function get(_target, prop) {
-              globalThis.console.warn(
-                `You tried to import '${String(prop)}' from 'react-native' module on a Worklet Runtime. Using 'react-native' module on a Worklet Runtime is not allowed.`
-              );
-              return {
-                get() {
-                  return undefined;
-                },
-              };
-            },
-          }
-        );
-      };
-
-      const mod = {
-        dependencyMap: [],
-        factory,
-        hasError: false,
-        importedAll: {},
-        importedDefault: {},
-        isInitialized: false,
-        publicModule: {
-          exports: {},
-        },
-      };
-
-      modules.set(ReactNativeModuleId, mod);
-    }
-  }
-}
-
-/** A function that should be run only on RN Runtime in web implementation. */
-function initializeRuntimeOnWeb() {
-  globalThis._WORKLET = false;
-  globalThis._log = console.log;
-  globalThis._getAnimationTimestamp = () => performance.now();
-  if (IS_JEST) {
-    // 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: https://github.com/facebook/react-native/blob/main/packages/react-native/jest/setup.js#L28
-    // 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;
-  }
-}
-
-/**
- * A function that should be run on the RN Runtime to configure the UI Runtime
- * with callback bindings.
- */
-function installRNBindingsOnUIRuntime() {
-  if (!WorkletsModule) {
-    throw new WorkletsError(
-      'Worklets are trying to initialize the UI runtime without a valid WorkletsModule'
-    );
-  }
-
-  const runtimeBoundCapturableConsole = getMemorySafeCapturableConsole();
-
-  if (!globalThis._WORKLETS_BUNDLE_MODE) {
-    /** In bundle mode Runtimes setup their callGuard themselves. */
-    executeOnUIRuntimeSync(setupCallGuard)();
-
-    /**
-     * Register WorkletsError in the UI runtime global scope. (we are using
-     * `executeOnUIRuntimeSync` here to make sure that the changes are applied
-     * before any async operations are executed on the UI runtime).
-     *
-     * There's no need to register the error in bundle mode.
-     */
-    executeOnUIRuntimeSync(registerWorkletsError)();
-  }
-
-  executeOnUIRuntimeSync(() => {
-    'worklet';
-
-    setupConsole(runtimeBoundCapturableConsole);
-    /**
-     * TODO: Move `setupMicrotasks` and `setupRequestAnimationFrame` to a
-     * separate function once we have a better way to distinguish between
-     * Worklet Runtimes.
-     */
-    setupMicrotasks();
-    setupRequestAnimationFrame();
-    setupSetTimeout();
-    setupSetImmediate();
-    setupSetInterval();
-  })();
-}

package/src/isSynchronizable.ts

@@ -1,13 +0,0 @@
-'use strict';
-import type { Synchronizable } from './synchronizable';
-
-export function isSynchronizable<TValue>(
-  value: unknown
-): value is Synchronizable<TValue> {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    '__synchronizableRef' in value &&
-    value.__synchronizableRef === true
-  );
-}

package/src/logger.ts

@@ -1,16 +0,0 @@
-'use strict';
-
-const PREFIX = '[Worklets]';
-
-function formatMessage(message: string) {
-  return `${PREFIX} ${message}`;
-}
-
-export const logger = {
-  warn(message: string) {
-    console.warn(formatMessage(message));
-  },
-  error(message: string) {
-    console.error(formatMessage(message));
-  },
-};

package/src/publicGlobals.ts

@@ -1,39 +0,0 @@
-'use strict';
-/* eslint-disable reanimated/use-global-this */
-import type { RuntimeKind } from './runtimeKind';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { getRuntimeKind } from './runtimeKind';
-
-export {};
-
-declare global {
-  /**
-   * @deprecated Use {@link __RUNTIME_KIND} instead.
-   *
-   *   This global variable is a diagnostic/development tool.
-   *
-   *   It's `true` on Worklet Runtimes and `false` on React Native Runtime.
-   */
-  var _WORKLET: boolean | undefined;
-
-  /**
-   * This ArrayBuffer contains the memory address of `jsi::Runtime` which is the
-   * Reanimated UI runtime.
-   */
-  var _WORKLET_RUNTIME: ArrayBuffer;
-
-  /** @deprecated Don't use. */
-  var _IS_FABRIC: boolean | undefined;
-
-  /**
-   * This global variable is used to determine the kind of the current runtime.
-   * You can use it directly to differentiate between runtimes. However, the
-   * recommended way for differentiating is to use the {@link getRuntimeKind}
-   * function.
-   *
-   * - Value _1_: React Native Runtime
-   * - Value _2_: UI Worklet Runtime
-   * - Value _3_: Worker Worklet Runtime
-   */
-  var __RUNTIME_KIND: RuntimeKind | 1 | 2 | 3;
-}

package/src/runLoop/common/setImmediatePolyfill.ts

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

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

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

@@ -1,66 +0,0 @@
-'use strict';
-
-import { callMicrotasks } from '../../threads';
-
-export function setupRequestAnimationFrame() {
-  'worklet';
-  const nativeRequestAnimationFrame = globalThis.requestAnimationFrame;
-
-  let queuedCallbacks: ((timestamp: number) => void)[] = [];
-  let queuedCallbacksBegin = 0;
-  let queuedCallbacksEnd = 0;
-
-  let flushedCallbacks = queuedCallbacks;
-  let flushedCallbacksBegin = 0;
-  let flushedCallbacksEnd = 0;
-
-  let flushRequested = false;
-
-  globalThis.__flushAnimationFrame = (timestamp: number) => {
-    flushedCallbacks = queuedCallbacks;
-    queuedCallbacks = [];
-
-    flushedCallbacksBegin = queuedCallbacksBegin;
-    flushedCallbacksEnd = queuedCallbacksEnd;
-    queuedCallbacksBegin = queuedCallbacksEnd;
-
-    for (const callback of flushedCallbacks) {
-      callback(timestamp);
-    }
-
-    flushedCallbacksBegin = flushedCallbacksEnd;
-
-    callMicrotasks();
-  };
-
-  globalThis.requestAnimationFrame = (
-    callback: (timestamp: number) => void
-  ): number => {
-    const handle = queuedCallbacksEnd++;
-
-    queuedCallbacks.push(callback);
-    if (!flushRequested) {
-      flushRequested = true;
-
-      nativeRequestAnimationFrame((timestamp) => {
-        flushRequested = false;
-        globalThis.__frameTimestamp = timestamp;
-        globalThis.__flushAnimationFrame(timestamp);
-        globalThis.__frameTimestamp = undefined;
-      });
-    }
-    return handle;
-  };
-
-  globalThis.cancelAnimationFrame = (handle: number) => {
-    if (handle < flushedCallbacksBegin || handle >= queuedCallbacksEnd) {
-      return;
-    }
-
-    if (handle < flushedCallbacksEnd) {
-      flushedCallbacks[handle - flushedCallbacksBegin] = () => {};
-    } else {
-      queuedCallbacks[handle - queuedCallbacksBegin] = () => {};
-    }
-  };
-}