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

package/src/WorkletsModule/workletsModuleProxy.ts

@@ -0,0 +1,247 @@
+'use strict';
+
+import type {
+  RemoteFunction,
+  SerializableRef,
+  SynchronizableRef,
+} from '../memory/types';
+import type { WorkletRuntime } from '../types';
+
+/** Type of `__workletsModuleProxy` injected with JSI. */
+export interface WorkletsModuleProxy {
+  loadUnpackersWithCode(
+    valueUnpackerCode: string,
+    valueUnpackerLocation: string,
+    valueUnpackerSourceMap: string,
+    synchronizableUnpackerCode: string,
+    synchronizableUnpackerLocation: string,
+    synchronizableUnpackerSourceMap: string,
+    customSerializableUnpackerCode: string,
+    customSerializableUnpackerLocation: string,
+    customSerializableUnpackerSourceMap: string,
+    shareableHostUnpackerCode: string,
+    shareableHostUnpackerLocation: string,
+    shareableHostUnpackerSourceMap: string,
+    shareableGuestUnpackerCode: string,
+    shareableGuestUnpackerLocation: string,
+    shareableGuestUnpackerSourceMap: string,
+    remoteFunctionUnpackerCode: string,
+    remoteFunctionUnpackerLocation: string,
+    remoteFunctionUnpackerSourceMap: string
+  ): void;
+
+  loadUnpackersWithBytecode(
+    valueUnpackerBytecode: ArrayBuffer,
+    synchronizableUnpackerBytecode: ArrayBuffer,
+    customSerializableUnpackerBytecode: ArrayBuffer,
+    shareableHostUnpackerBytecode: ArrayBuffer,
+    shareableGuestUnpackerBytecode: ArrayBuffer,
+    remoteFunctionUnpackerBytecode: ArrayBuffer
+  ): void;
+
+  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[]>;
+
+  createSerializableArrayBuffer(
+    arrayBuffer: ArrayBuffer
+  ): SerializableRef<ArrayBuffer>;
+
+  createSerializableMap<TKey, TValue>(
+    keys: TKey[],
+    values: TValue[]
+  ): SerializableRef<Map<TKey, TValue>>;
+
+  createSerializableSet<TValues>(
+    values: TValues[]
+  ): SerializableRef<Set<TValues>>;
+
+  createSerializableError(
+    name: string,
+    message: string,
+    stack: string | undefined
+  ): SerializableRef<Error>;
+
+  createSerializableRegExp(
+    pattern: string,
+    flags: string
+  ): SerializableRef<RegExp>;
+
+  createSerializableArrayBufferView<TValue extends ArrayBufferView>(
+    typeName: string,
+    buffer: ArrayBuffer,
+    byteOffset: number,
+    length: number
+  ): SerializableRef<TValue>;
+
+  createSerializableInitializer(obj: object): SerializableRef<object>;
+
+  createSerializableNonWorkletFunction<TArgs extends unknown[], TReturn>(
+    fun: (...args: TArgs) => TReturn,
+    functionName: string | undefined
+  ): SerializableRef<(...args: TArgs) => TReturn>;
+
+  createSerializableWorklet(
+    worklet: object,
+    shouldPersistRemote: boolean
+  ): SerializableRef<object>;
+
+  createCustomSerializable(
+    data: SerializableRef<unknown>,
+    typeId: number
+  ): SerializableRef<unknown>;
+
+  registerCustomSerializable(
+    determine: SerializableRef<object>,
+    pack: SerializableRef<object>,
+    unpack: SerializableRef<object>,
+    typeId: number
+  ): void;
+
+  createShareable<TValue = unknown>(
+    hostRuntimeId: number,
+    initial: SerializableRef<TValue>,
+    initSynchronously: boolean,
+    decorateHost: SerializableRef,
+    decorateGuest: SerializableRef
+  ): SerializableRef<TValue>;
+
+  scheduleOnRN<TArgs extends unknown[]>(
+    fun: RemoteFunction | ((...args: TArgs) => unknown),
+    args: SerializableRef<TArgs> | undefined
+  ): void;
+
+  scheduleOnUI<TValue>(
+    serializableArrayOfWorklets: SerializableRef<TValue[]>,
+    scheduleStacks: string[] | undefined
+  ): void;
+
+  runOnUISync<TValue, TReturn>(
+    serializable: SerializableRef<TValue>,
+    scheduleStack: string | undefined
+  ): TReturn;
+
+  createWorkletRuntime(
+    name: string,
+    initializer: SerializableRef<() => void>,
+    useDefaultQueue: boolean,
+    customQueue: object | undefined,
+    enableEventLoop: boolean
+  ): WorkletRuntime;
+
+  scheduleOnRuntime<TValue>(
+    workletRuntime: WorkletRuntime,
+    worklet: SerializableRef<TValue>,
+    scheduleStack?: string
+  ): void;
+
+  scheduleOnRuntimeWithId<TValue>(
+    runtimeId: number,
+    worklet: SerializableRef<TValue>,
+    scheduleStack?: string
+  ): void;
+
+  runOnRuntimeSync<TValue, TReturn>(
+    workletRuntime: WorkletRuntime,
+    worklet: SerializableRef<TValue>,
+    scheduleStack?: string
+  ): TReturn;
+
+  runOnRuntimeSyncWithId<TValue, TReturn>(
+    runtimeId: number,
+    worklet: SerializableRef<TValue>,
+    scheduleStack?: string
+  ): TReturn;
+
+  handlePromise<TValue>(
+    resolveOrReject:
+      | ((value: TValue | PromiseLike<TValue>) => void)
+      | RemoteFunction,
+    valueOrError: SerializableRef<TValue>
+  ): void;
+
+  reportFatalErrorOnJS(message: string, stack: string, name: 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;
+
+  getUIRuntimeHolder(): object;
+
+  getUISchedulerHolder(): object;
+
+  /** @deprecated Don't use unless you have to. */
+  createSerializableLEGACY<TValue>(
+    value: TValue,
+    nativeStateSource: object | undefined
+  ): SerializableRef<TValue>;
+}
+
+type InternalMethods =
+  | 'loadUnpackersWithCode'
+  | 'loadUnpackersWithBytecode'
+  | 'createSerializableLEGACY';
+
+type TurboModulePublic = {
+  toggleSlowAnimationsOnUIRuntime(): boolean;
+};
+
+export type IWorkletsModule = Omit<WorkletsModuleProxy, InternalMethods> &
+  TurboModulePublic;

package/src/bundleMode/metroOverrides.native.ts

@@ -0,0 +1,33 @@
+'use strict';
+
+import { isWorkletRuntime } from '../runtimeKind';
+
+/**
+ * Evaluating HMR updates on Worklet Runtimes leads to verbose warnings which
+ * don't affect runtime. This function silences those warnings by providing a
+ * dummy Refresh module to the global scope.
+ *
+ * Use only in dev builds.
+ */
+export function silenceHMRWarnings() {
+  assertWorkletRuntime('silenceHMRWarnings');
+
+  const Refresh = new Proxy(
+    {},
+    {
+      get() {
+        return () => {};
+      },
+    }
+  );
+
+  globalThis.__r.Refresh = Refresh;
+}
+
+function assertWorkletRuntime(functionName: string) {
+  if (!isWorkletRuntime()) {
+    throw new Error(
+      `[Worklets] ${functionName} can be used only on Worklet Runtimes.`
+    );
+  }
+}

package/src/bundleMode/network.native.ts

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * Mocks necessary networking TurboModules on Worklet Runtimes to prevent
+ * crashes when code running on Worklet Runtimes tries to use networking APIs.
+ * The NetworkingModule itself is injected via C++.
+ */
+export function initializeNetworking() {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require('react-native/Libraries/TurboModule/TurboModuleRegistry');
+  const TurboModules = globalThis.TurboModules;
+
+  TurboModules.set('FileReaderModule', makeMockTurboModule('FileReaderModule'));
+  TurboModules.set(
+    'PlatformConstants',
+    makeMockTurboModule('PlatformConstants')
+  );
+  TurboModules.set('WebSocketModule', makeMockTurboModule('WebSocketModule'));
+  TurboModules.set(
+    'NativeReactNativeFeatureFlagsCxx',
+    new Proxy({}, { get: () => () => undefined })
+  );
+  TurboModules.set(
+    'BlobModule',
+    makeMockTurboModule('BlobModule', ['addNetworkingHandler'])
+  );
+
+  /**
+   * This require statement below is the key part of the implementation here. It
+   * pulls all the code that properly sets up XHR on a Runtime, using underlying
+   * C++ NetworkingModule. Thanks to that we can have the same JavaScript
+   * implementation for fetch on all runtimes in the app and we don't have to
+   * write the code ourselves.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require('react-native/Libraries/Core/setUpXHR');
+}
+
+const noopMethods = ['getConstants'];
+
+function makeMockTurboModule(name: string, extraNoopMethods?: string[]) {
+  const proxy = new Proxy(
+    {},
+    {
+      get: function get(_target, prop) {
+        if (
+          [...noopMethods, ...(extraNoopMethods ?? [])].includes(prop as string)
+        ) {
+          return () => {
+            return () => {};
+          };
+        }
+        throw new Error(
+          `[Worklets] You tried to call method '${String(
+            prop
+          )}' from '${name}' TurboModule on a Worklet Runtime. Using '${name}' TurboModule on a Worklet Runtime is not allowed.`
+        );
+      },
+    }
+  );
+
+  return proxy;
+}

package/src/debug/bundleMode.native.ts

@@ -0,0 +1,18 @@
+'use strict';
+
+import type { WorkletFunction } from '../types';
+
+// Worklets Babel Plugin replaces `false` with `true` here
+// when Bundle Mode is enabled.
+globalThis._WORKLETS_BUNDLE_MODE_ENABLED = false;
+
+export function isBundleModeEnabled(): boolean {
+  return (
+    globalThis._WORKLETS_BUNDLE_MODE_ENABLED === true &&
+    (
+      (() => {
+        'worklet';
+      }) as WorkletFunction
+    ).__initData === undefined
+  );
+}

package/src/debug/bundleMode.ts

@@ -0,0 +1,5 @@
+'use strict';
+
+export function isBundleModeEnabled(): boolean {
+  return false;
+}

package/src/debug/checkCppVersion.ts

@@ -0,0 +1,34 @@
+'use strict';
+
+import { jsVersion } from './jsVersion';
+import { logger } from './logger';
+
+export function checkCppVersion() {
+  const cppVersion = global._WORKLETS_VERSION_CPP;
+  if (cppVersion === undefined) {
+    logger.warn(
+      `Couldn't determine the version of the native part of Worklets.
+    See \`https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#couldnt-determine-the-version-of-the-native-part-of-worklets\` for more details.`
+    );
+    return;
+  }
+  const ok = matchVersion(jsVersion, cppVersion);
+  if (!ok) {
+    throw new Error(
+      `[Worklets] Mismatch between JavaScript part and native part of Worklets (${jsVersion} vs ${cppVersion}).
+    See \`https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#mismatch-between-javascript-part-and-native-part-of-worklets\` for more details.`
+    );
+  }
+}
+
+export function matchVersion(version1: string, version2: string) {
+  if (version1.match(/^\d+\.\d+\.\d+$/) && version2.match(/^\d+\.\d+\.\d+$/)) {
+    // x.y.z, compare only major and minor, skip patch
+    const [major1, minor1] = version1.split('.');
+    const [major2, minor2] = version2.split('.');
+    return major1 === major2 && minor1 === minor2;
+  } else {
+    // alpha, beta or rc, compare everything
+    return version1 === version2;
+  }
+}

package/src/debug/errors.native.ts

@@ -0,0 +1,74 @@
+'use strict';
+
+import type { WorkletStackDetails } from '../types';
+
+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;
+}
+
+/**
+ * Remote error is an error coming from a Worklet Runtime that we bubble up to
+ * the RN Runtime.
+ */
+export function reportFatalRemoteError(
+  { message, stack, name }: Error,
+  force: boolean
+): void {
+  const error = new Error('[Worklets]');
+  error.message = message;
+  error.stack = processStack(stack);
+  error.name = name;
+  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/debug/jsVersion.ts

@@ -0,0 +1,8 @@
+'use strict';
+
+/**
+ * We hardcode the version of Worklets here in order to compare it with the
+ * version used to build the native part of the library in runtime. Remember to
+ * keep this in sync with the version declared in `package.json`
+ */
+export const jsVersion = '0.11.3';

package/src/debug/logger.ts

@@ -0,0 +1,16 @@
+'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/debug/slowAnimations.native.ts

@@ -0,0 +1,15 @@
+'use strict';
+import { WorkletsModule } from '../WorkletsModule/NativeWorklets';
+
+/**
+ * Toggles slow animations on the UI runtime. When enabled, animations will run
+ * at a reduced speed to aid debugging.
+ *
+ * Available only on Android. iOS offers built-in slow animations toggle.
+ *
+ * @returns Whether slow animations are now enabled.
+ * @throws When invoked on platform different than Android.
+ */
+export function toggleSlowAnimationsOnUIRuntime(): boolean {
+  return WorkletsModule.toggleSlowAnimationsOnUIRuntime();
+}

package/src/debug/slowAnimations.ts

@@ -0,0 +1,6 @@
+'use strict';
+
+export function toggleSlowAnimationsOnUIRuntime() {
+  // noop
+  return false;
+}

package/src/deprecated.ts

@@ -0,0 +1,38 @@
+'use strict';
+
+import {
+  createSerializable,
+  isSerializableRef,
+  makeShareable,
+  makeShareableCloneOnUIRecursive,
+} from './memory/serializable';
+import { serializableMappingCache } from './memory/serializableMappingCache';
+import type { SerializableRef } from './memory/types';
+
+/** @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;
+
+/** @deprecated NOOP, don't use. */
+export function callMicrotasks(): void {
+  'worklet';
+  // NOOP for backwards compatibility.
+}

package/src/featureFlags/featureFlags.native.ts

@@ -0,0 +1,70 @@
+'use strict';
+import { logger } from '../debug/logger';
+import { WorkletsModule } from '../WorkletsModule/NativeWorklets';
+import type {
+  DynamicFlagName,
+  DynamicFlagsType,
+  StaticFeatureFlagsSchema,
+} from './types';
+
+export const DynamicFlags: DynamicFlagsType = {
+  EXAMPLE_DYNAMIC_FLAG: true,
+
+  init() {
+    Object.keys(DynamicFlags).forEach((key) => {
+      if (key !== 'init' && key !== 'setFlag' && key !== 'getFlag') {
+        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.`
+      );
+    }
+  },
+  getFlag(name) {
+    if (name in DynamicFlags) {
+      return DynamicFlags[name];
+    } else {
+      logger.warn(
+        `The feature flag: '${name}' no longer exists, you can safely remove invocation of \`getDynamicFeatureFlag('${name}')\` from your code.`
+      );
+      return false;
+    }
+  },
+};
+DynamicFlags.init();
+
+// Public API function to update a feature flag
+export function setDynamicFeatureFlag(
+  name: DynamicFlagName,
+  value: boolean
+): void {
+  DynamicFlags.setFlag(name, value);
+}
+
+// Public API function to read a feature flag
+export function getDynamicFeatureFlag(name: DynamicFlagName): boolean {
+  return DynamicFlags.getFlag(name);
+}
+
+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/featureFlags/featureFlags.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+import type { DynamicFlagName, StaticFeatureFlagsSchema } from './types';
+
+export function getStaticFeatureFlag(
+  _name: keyof StaticFeatureFlagsSchema
+): boolean {
+  return false;
+}
+
+export function setDynamicFeatureFlag(
+  _name: DynamicFlagName,
+  _value: boolean
+): void {
+  // no-op
+}
+
+export function getDynamicFeatureFlag(_name: DynamicFlagName): boolean {
+  return false;
+}

package/src/featureFlags/staticFlags.json

@@ -0,0 +1,6 @@
+{
+  "RUNTIME_TEST_FLAG": false,
+  "FETCH_PREVIEW_ENABLED": false,
+  "IOS_DYNAMIC_FRAMERATE_ENABLED": true,
+  "ENABLE_CROSS_RUNTIME_STACK_TRACES": true
+}