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

package/src/featureFlags/types.ts

@@ -0,0 +1,32 @@
+'use strict';
+
+import type StaticFeatureFlagsJSON from './staticFlags.json';
+
+export type DynamicFlagsType = {
+  EXAMPLE_DYNAMIC_FLAG: boolean;
+  init(): void;
+  setFlag(name: DynamicFlagName, value: boolean): void;
+  getFlag(name: DynamicFlagName): boolean;
+};
+
+export type DynamicFlagName = keyof Omit<
+  Omit<DynamicFlagsType, 'setFlag' | 'getFlag'>,
+  'init'
+>;
+
+/**
+ * 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,
+  FETCH_PREVIEW_ENABLED: false,
+  IOS_DYNAMIC_FRAMERATE_ENABLED: true,
+  ENABLE_CROSS_RUNTIME_STACK_TRACES: true,
+} as const satisfies typeof StaticFeatureFlagsJSON;
+
+export type StaticFeatureFlagsSchema = {
+  -readonly [K in keyof typeof DefaultStaticFeatureFlags]: boolean;
+};

package/src/guardImplementation.native.ts

@@ -0,0 +1,26 @@
+'use strict';
+
+import { createSerializable } from './memory/serializable';
+import { serializableMappingCache } from './memory/serializableMappingCache';
+
+export function addGuardImplementation<Args extends unknown[]>(
+  fn: (...args: Args) => unknown,
+  errorMessage: string
+): void {
+  const serializableGuard = createSerializable(function guardImplementation() {
+    'worklet';
+    throw new Error(`[Worklets] ${errorMessage}`);
+  });
+  serializableMappingCache.set(fn, serializableGuard);
+}
+
+export function addNoBundleModeGuardImplementation<Args extends unknown[]>(
+  fn: (...args: Args) => unknown
+): void {
+  const name = fn.name;
+
+  addGuardImplementation(
+    fn,
+    `${name} cannot be called on Worklet Runtimes outside of the Bundle Mode.`
+  );
+}

package/src/index.ts

@@ -0,0 +1,95 @@
+'use strict';
+
+import { init } from './initializers/initializers';
+
+// Worklets Babel Plugin replaces `false` with `true` here
+// when Bundle Mode is enabled.
+globalThis._WORKLETS_BUNDLE_MODE_ENABLED = false;
+
+// is-tree-shakable-suppress
+init();
+
+export { isBundleModeEnabled } from './debug/bundleMode';
+export { toggleSlowAnimationsOnUIRuntime } from './debug/slowAnimations';
+export {
+  callMicrotasks,
+  isShareableRef,
+  makeShareable,
+  type MakeShareableClone,
+  makeShareableCloneOnUIRecursive,
+  makeShareableCloneRecursive,
+  shareableMappingCache,
+  type ShareableRef,
+} from './deprecated';
+export {
+  getDynamicFeatureFlag,
+  getStaticFeatureFlag,
+  setDynamicFeatureFlag,
+} from './featureFlags/featureFlags';
+export { isShareable } from './memory/isShareable';
+export { isSynchronizable } from './memory/isSynchronizable';
+export {
+  createSerializable,
+  isSerializableRef,
+  registerCustomSerializable,
+} from './memory/serializable';
+export { serializableMappingCache } from './memory/serializableMappingCache';
+export { createShareable } from './memory/shareable';
+export { createSynchronizable } from './memory/synchronizable';
+export type {
+  RegistrationData,
+  SerializableRef,
+  Shareable,
+  ShareableConfig,
+  ShareableGuest,
+  ShareableGuestDecorator,
+  ShareableGuestMeta,
+  ShareableGuestProps,
+  ShareableHost,
+  ShareableHostDecorator,
+  ShareableHostMeta,
+  ShareableHostProps,
+  Synchronizable,
+  SynchronizableRef,
+} from './memory/types';
+export {
+  getRuntimeKind,
+  isRNRuntime,
+  isUIRuntime,
+  isWorkerRuntime,
+  isWorkletRuntime,
+  RuntimeKind,
+} from './runtimeKind';
+export {
+  createWorkletRuntime,
+  getUIRuntimeHolder,
+  getUISchedulerHolder,
+  runOnRuntime,
+  runOnRuntimeAsync,
+  runOnRuntimeAsyncWithId,
+  runOnRuntimeSync,
+  runOnRuntimeSyncWithId,
+  scheduleOnRuntime,
+  scheduleOnRuntimeWithId,
+  UIRuntimeId,
+} from './runtimes';
+export {
+  executeOnUIRuntimeSync,
+  runOnJS,
+  runOnUI,
+  runOnUIAsync,
+  runOnUISync,
+  scheduleOnRN,
+  scheduleOnUI,
+} from './threads';
+export type {
+  WorkletFunction,
+  WorkletRuntime,
+  WorkletStackDetails,
+} from './types';
+export { isWorkletFunction } from './workletFunction';
+export { WorkletsModule } from './WorkletsModule/NativeWorklets';
+export type {
+  IWorkletsModule,
+  WorkletsModuleProxy,
+} from './WorkletsModule/workletsModuleProxy';

package/src/initializers/initializers.native.ts

@@ -0,0 +1,218 @@
+'use strict';
+
+import { silenceHMRWarnings } from '../bundleMode/metroOverrides';
+import { initializeNetworking } from '../bundleMode/network';
+import { registerReportFatalRemoteError } from '../debug/errors';
+import { getStaticFeatureFlag } from '../featureFlags/featureFlags';
+import { bundleValueUnpacker } from '../memory/bundleUnpacker';
+import { installCustomSerializableUnpacker } from '../memory/customSerializableUnpacker';
+import { installRemoteFunctionUnpacker } from '../memory/remoteFunctionUnpacker';
+import { makeShareableCloneOnUIRecursive } from '../memory/serializable';
+import { installShareableGuestUnpacker } from '../memory/shareableGuestUnpacker';
+import { installShareableHostUnpacker } from '../memory/shareableHostUnpacker';
+import { installSynchronizableUnpacker } from '../memory/synchronizableUnpacker';
+import { installValueUnpacker } from '../memory/valueUnpacker';
+import { setupSetImmediate } from '../runLoop/common/setImmediatePolyfill';
+import { setupSetInterval } from '../runLoop/common/setIntervalPolyfill';
+import { setupRequestAnimationFrame } from '../runLoop/uiRuntime/requestAnimationFrame';
+import { setupSetTimeout } from '../runLoop/uiRuntime/setTimeoutPolyfill';
+import { RuntimeKind } from '../runtimeKind';
+import { runOnUISync, scheduleOnRN, setupMicrotasks } from '../threads';
+import type { ValueUnpacker } from '../types';
+import { isWorkletFunction } from '../workletFunction';
+import { WorkletsModule } from '../WorkletsModule/NativeWorklets';
+
+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;
+}
+
+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: (...args) => scheduleOnRN(boundCapturableConsole.assert, ...args),
+    debug: (...args) => scheduleOnRN(boundCapturableConsole.debug, ...args),
+    log: (...args) => scheduleOnRN(boundCapturableConsole.log, ...args),
+    warn: (...args) => scheduleOnRN(boundCapturableConsole.warn, ...args),
+    error: (...args) => scheduleOnRN(boundCapturableConsole.error, ...args),
+    info: (...args) => scheduleOnRN(boundCapturableConsole.info, ...args),
+  };
+}
+
+// This is only used in DEV mode in Bunde Mode, it's necessary to see the logs in metro / devtools
+export function setupConsoleForwarding(boundCapturableConsole: typeof console) {
+  'worklet';
+
+  globalThis.nativeLoggingHook = (message: string, level: number) => {
+    switch (level) {
+      case 0:
+        scheduleOnRN(boundCapturableConsole.debug, message);
+        break;
+      case 1:
+        scheduleOnRN(boundCapturableConsole.log, message);
+        break;
+      case 2:
+        scheduleOnRN(boundCapturableConsole.warn, message);
+        break;
+      case 3:
+        scheduleOnRN(boundCapturableConsole.error, message);
+        break;
+      default:
+        scheduleOnRN(boundCapturableConsole.log, message);
+    }
+  };
+}
+
+export function setupSerializer() {
+  'worklet';
+  globalThis.__serializer = makeShareableCloneOnUIRecursive;
+}
+
+let initialized = false;
+
+export function init() {
+  if (initialized) {
+    return;
+  }
+  initialized = true;
+
+  initializeRuntime();
+
+  if (globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
+    initializeWorkletRuntime();
+  } else {
+    initializeRNRuntime();
+    installRNBindingsOnUIRuntime();
+  }
+}
+
+/** A function that should be run on any kind of runtime. */
+function initializeRuntime() {
+  if (globalThis._WORKLETS_BUNDLE_MODE_ENABLED) {
+    globalThis.__valueUnpacker = bundleValueUnpacker as ValueUnpacker;
+  } else {
+    installValueUnpacker();
+  }
+  installSynchronizableUnpacker();
+  installCustomSerializableUnpacker();
+  installShareableHostUnpacker();
+  installShareableGuestUnpacker();
+  installRemoteFunctionUnpacker();
+}
+
+/** A function that should be run only on React Native runtime. */
+function initializeRNRuntime() {
+  if (__DEV__) {
+    const testWorklet = () => {
+      'worklet';
+    };
+    if (!isWorkletFunction(testWorklet)) {
+      throw new Error(
+        `[Worklets] 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_ENABLED) {
+    if (__DEV__) {
+      silenceHMRWarnings();
+    }
+
+    if (getStaticFeatureFlag('FETCH_PREVIEW_ENABLED')) {
+      initializeNetworking();
+    }
+  }
+}
+
+/**
+ * A function that should be run on the RN Runtime to configure the UI Runtime
+ * with callback bindings.
+ */
+function installRNBindingsOnUIRuntime() {
+  if (!WorkletsModule) {
+    throw new Error(
+      '[Worklets] Worklets are trying to initialize the UI runtime without a valid WorkletsModule'
+    );
+  }
+
+  const runtimeBoundCapturableConsole =
+    globalThis._WORKLETS_BUNDLE_MODE_ENABLED && !__DEV__
+      ? null
+      : getMemorySafeCapturableConsole();
+
+  runOnUISync(() => {
+    'worklet';
+    /**
+     * TODO: Move `setupMicrotasks` and `setupRequestAnimationFrame` to a
+     * separate function once we have a better way to distinguish between
+     * Worklet Runtimes.
+     */
+
+    if (!globalThis._WORKLETS_BUNDLE_MODE_ENABLED) {
+      setupConsole(runtimeBoundCapturableConsole!);
+    } else if (__DEV__) {
+      setupConsoleForwarding(runtimeBoundCapturableConsole!);
+    }
+
+    setupMicrotasks();
+    setupRequestAnimationFrame();
+    setupSetTimeout();
+    setupSetImmediate();
+    setupSetInterval();
+    setupSerializer();
+  });
+}

package/src/initializers/initializers.ts

@@ -0,0 +1,24 @@
+'use strict';
+
+import { IS_JEST } from '../platformChecker';
+import { mockedRequestAnimationFrame } from '../runLoop/uiRuntime/mockedRequestAnimationFrame';
+import { RuntimeKind } from '../runtimeKind';
+
+export function init() {
+  globalThis._WORKLET = false;
+  globalThis.__RUNTIME_KIND = RuntimeKind.ReactNative;
+  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. 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.
+    globalThis.requestAnimationFrame = mockedRequestAnimationFrame;
+  }
+}

package/src/memory/bundleUnpacker.native.ts

@@ -0,0 +1,59 @@
+'use strict';
+
+import { logger } from '../debug/logger';
+import type { WorkletFactory, WorkletFunction } from '../types';
+
+const handleCache = new WeakMap<WorkletFunction, unknown>();
+
+export function bundleValueUnpacker(objectToUnpack: ObjectToUnpack): 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 {
+    throw new Error(
+      `[Worklets] Data type 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. Original error: ${(e as Error).message}`
+      );
+    }
+  } 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/memory/customSerializableUnpacker.native.ts

@@ -0,0 +1,30 @@
+'use strict';
+
+export function installCustomSerializableUnpacker() {
+  'worklet';
+  'no-worklet-closure';
+  if (!globalThis.__customSerializationRegistry) {
+    globalThis.__customSerializationRegistry =
+      [] as typeof globalThis.__customSerializationRegistry;
+  }
+  const registry = globalThis.__customSerializationRegistry;
+
+  function customSerializableUnpacker<TValue>(value: TValue, typeId: number) {
+    const data = registry[typeId];
+    if (!data) {
+      throw new Error(
+        `[Worklets] No custom serializable registered for type ID ${typeId}.`
+      );
+    }
+
+    return data.unpack(value as object);
+  }
+
+  globalThis.__customSerializableUnpacker =
+    customSerializableUnpacker as CustomSerializableUnpacker;
+}
+
+export type CustomSerializableUnpacker = (
+  object: unknown,
+  typeId: number
+) => unknown;

package/src/memory/isShareable.ts

@@ -0,0 +1,16 @@
+'use strict';
+
+import type { Shareable } from './types';
+
+export function isShareable<
+  TValue = unknown,
+  THostDecorated = unknown,
+  TGuestDecorated = unknown,
+>(value: unknown): value is Shareable<TValue, THostDecorated, TGuestDecorated> {
+  'worklet';
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    !!(value as Record<string, unknown>).__shareableRef
+  );
+}

package/src/memory/isSynchronizable.ts

@@ -0,0 +1,14 @@
+'use strict';
+
+import type { Synchronizable } from './types';
+
+export function isSynchronizable<TValue>(
+  value: unknown
+): value is Synchronizable<TValue> {
+  'worklet';
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    !!(value as Record<string, unknown>).__synchronizableRef
+  );
+}

package/src/memory/remoteFunctionUnpacker.native.ts

@@ -0,0 +1,27 @@
+'use strict';
+
+export function installRemoteFunctionUnpacker() {
+  'worklet';
+  'no-worklet-closure';
+
+  function remoteFunctionUnpacker(
+    remoteFunctionName: string | undefined
+  ): unknown {
+    remoteFunctionName = remoteFunctionName ? remoteFunctionName : 'anonymous';
+
+    const fun = function remoteFunctionGuard() {
+      throw new Error(`[Worklets] Tried to synchronously call a Remote Function. Called "${remoteFunctionName}" on the ${globalThis.__RUNTIME_NAME} Runtime.
+See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#tried-to-synchronously-call-a-remote-function for more details.`);
+    };
+
+    fun.__remoteFunction = true;
+    return fun;
+  }
+
+  globalThis.__remoteFunctionUnpacker =
+    remoteFunctionUnpacker as RemoteFunctionUnpacker;
+}
+
+export type RemoteFunctionUnpacker = (
+  remoteFunctionName: string | undefined
+) => unknown;