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

package/src/WorkletsModule/workletsModuleProxy.ts

@@ -1,126 +0,0 @@
-'use strict';
-
-import type { SynchronizableRef } from '../synchronizable';
-import type { SerializableRef, WorkletRuntime } from '../workletTypes';
-
-/** Type of `__workletsModuleProxy` injected with JSI. */
-export interface WorkletsModuleProxy {
-  createSerializable<TValue>(
-    value: TValue,
-    shouldPersistRemote: boolean,
-    nativeStateSource?: object
-  ): SerializableRef<TValue>;
-
-  createSerializableImport<TValue>(
-    source: string,
-    imported: string
-  ): SerializableRef<TValue>;
-
-  createSerializableString(str: string): SerializableRef<string>;
-
-  createSerializableNumber(num: number): SerializableRef<number>;
-
-  createSerializableBoolean(bool: boolean): SerializableRef<boolean>;
-
-  createSerializableBigInt(bigInt: bigint): SerializableRef<bigint>;
-
-  createSerializableUndefined(): SerializableRef<undefined>;
-
-  createSerializableNull(): SerializableRef<null>;
-
-  createSerializableTurboModuleLike<
-    TProps extends object,
-    TProto extends object,
-  >(
-    props: TProps,
-    proto: TProto
-  ): SerializableRef<TProps>;
-
-  createSerializableObject<T extends object>(
-    obj: T,
-    shouldRetainRemote: boolean,
-    nativeStateSource?: object
-  ): SerializableRef<T>;
-
-  createSerializableHostObject<T extends object>(obj: T): SerializableRef<T>;
-
-  createSerializableArray(
-    array: unknown[],
-    shouldRetainRemote: boolean
-  ): SerializableRef<unknown[]>;
-
-  createSerializableMap<TKey, TValue>(
-    keys: TKey[],
-    values: TValue[]
-  ): SerializableRef<Map<TKey, TValue>>;
-
-  createSerializableSet<TValues>(
-    values: TValues[]
-  ): SerializableRef<Set<TValues>>;
-
-  createSerializableInitializer(obj: object): SerializableRef<object>;
-
-  createSerializableFunction<TArgs extends unknown[], TReturn>(
-    func: (...args: TArgs) => TReturn
-  ): SerializableRef<TReturn>;
-
-  createSerializableWorklet(
-    worklet: object,
-    shouldPersistRemote: boolean
-  ): SerializableRef<object>;
-
-  scheduleOnUI<TValue>(serializable: SerializableRef<TValue>): void;
-
-  executeOnUIRuntimeSync<TValue, TReturn>(
-    serializable: SerializableRef<TValue>
-  ): TReturn;
-
-  createWorkletRuntime(
-    name: string,
-    initializer: SerializableRef<() => void>,
-    useDefaultQueue: boolean,
-    customQueue: object | undefined,
-    enableEventLoop: boolean
-  ): WorkletRuntime;
-
-  scheduleOnRuntime<TValue>(
-    workletRuntime: WorkletRuntime,
-    worklet: SerializableRef<TValue>
-  ): void;
-
-  reportFatalErrorOnJS(
-    message: string,
-    stack: string,
-    name: string,
-    jsEngine: string
-  ): void;
-
-  createSynchronizable<TValue>(value: TValue): SynchronizableRef<TValue>;
-
-  synchronizableGetDirty<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>
-  ): TValue;
-
-  synchronizableGetBlocking<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>
-  ): TValue;
-
-  synchronizableSetBlocking<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>,
-    value: SerializableRef<TValue>
-  ): void;
-
-  synchronizableLock<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>
-  ): void;
-
-  synchronizableUnlock<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>
-  ): void;
-
-  getStaticFeatureFlag(name: string): boolean;
-
-  setDynamicFeatureFlag(name: string, value: boolean): void;
-}
-
-export type IWorkletsModule = WorkletsModuleProxy;

package/src/bundleUnpacker.ts

@@ -1,75 +0,0 @@
-'use strict';
-import { logger } from './logger';
-import { WorkletsError } from './WorkletsError';
-import type { WorkletFactory, WorkletFunction } from './workletTypes';
-
-const handleCache = new WeakMap<WorkletFunction, unknown>();
-
-export function bundleValueUnpacker(
-  objectToUnpack: ObjectToUnpack,
-  category?: string,
-  remoteFunctionName?: string
-): unknown {
-  const workletHash = objectToUnpack.__workletHash;
-  if (workletHash !== undefined) {
-    return getWorklet(workletHash, objectToUnpack.__closure);
-  } 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 remoteFunctionHolder = () => {
-      const label = remoteFunctionName
-        ? `function \`${remoteFunctionName}\``
-        : 'anonymous function';
-      throw new WorkletsError(`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.`);
-    };
-    remoteFunctionHolder.__remoteFunction = objectToUnpack;
-    return remoteFunctionHolder;
-  } else {
-    throw new WorkletsError(
-      `Data type in category "${category}" not recognized by value unpacker: "${globalThis._toString(
-        objectToUnpack
-      )}".`
-    );
-  }
-}
-
-function getWorklet(
-  workletHash: number,
-  closureVariables: Record<string, unknown>
-): WorkletFunction | undefined {
-  let worklet;
-  if (__DEV__) {
-    try {
-      worklet = getWorkletFromMetroRequire(workletHash, closureVariables);
-    } catch (_e) {
-      logger.error(
-        'Unable to resolve worklet with hash ' +
-          workletHash +
-          '. Try reloading the app.'
-      );
-    }
-  } else {
-    worklet = getWorkletFromMetroRequire(workletHash, closureVariables);
-  }
-  return worklet;
-}
-
-const metroRequire = globalThis.__r;
-
-function getWorkletFromMetroRequire(
-  workletHash: number,
-  closureVariables: Record<string, unknown>
-): WorkletFunction {
-  const factory = metroRequire(workletHash).default as WorkletFactory;
-  return factory(closureVariables);
-}
-
-interface ObjectToUnpack extends WorkletFunction {
-  _recur: unknown;
-}

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
-  );
-}