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

package/src/WorkletsModule/JSWorklets.ts

@@ -1,200 +0,0 @@
-'use strict';
-
-import { IS_JEST } from '../PlatformChecker';
-import { mockedRequestAnimationFrame } from '../runLoop/uiRuntime/mockedRequestAnimationFrame';
-import { WorkletsError } from '../WorkletsError';
-import type { SerializableRef } from '../workletTypes';
-import type { IWorkletsModule } from './workletsModuleProxy';
-
-export function createJSWorkletsModule(): IWorkletsModule {
-  return new JSWorklets();
-}
-
-// In Node.js environments (like when static rendering with Expo Router)
-// requestAnimationFrame is unavailable, so we use our mock.
-// It also has to be mocked for Jest purposes (see `initializeUIRuntime`).
-const requestAnimationFrameImpl =
-  IS_JEST || !globalThis.requestAnimationFrame
-    ? mockedRequestAnimationFrame
-    : globalThis.requestAnimationFrame;
-
-class JSWorklets implements IWorkletsModule {
-  createSerializable(): never {
-    throw new WorkletsError(
-      'createSerializable should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableString(): never {
-    throw new WorkletsError(
-      'createSerializableString should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableNumber(): never {
-    throw new WorkletsError(
-      'createSerializableNumber should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableBoolean(): never {
-    throw new WorkletsError(
-      'createSerializableBoolean should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableBigInt(): never {
-    throw new WorkletsError(
-      'createSerializableBigInt should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableUndefined(): never {
-    throw new WorkletsError(
-      'createSerializableUndefined should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableNull(): never {
-    throw new WorkletsError(
-      'createSerializableNull should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableTurboModuleLike(): never {
-    throw new WorkletsError(
-      'createSerializableTurboModuleLike should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableObject(): never {
-    throw new WorkletsError(
-      'createSerializableObject should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableMap(): never {
-    throw new WorkletsError(
-      'createSerializableMap should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableSet(): never {
-    throw new WorkletsError(
-      'createSerializableSet should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableImport(): never {
-    throw new WorkletsError(
-      'createSerializableImport should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableHostObject(): never {
-    throw new WorkletsError(
-      'createSerializableHostObject should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableArray(): never {
-    throw new WorkletsError(
-      'createSerializableArray should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableInitializer(): never {
-    throw new WorkletsError(
-      'createSerializableInitializer should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableFunction(): never {
-    throw new WorkletsError(
-      'createSerializableFunction should never be called in JSWorklets.'
-    );
-  }
-
-  createSerializableWorklet(): never {
-    throw new WorkletsError(
-      'createSerializableWorklet should never be called in JSWorklets.'
-    );
-  }
-
-  scheduleOnUI<TValue>(worklet: SerializableRef<TValue>) {
-    // TODO: `requestAnimationFrame` should be used exclusively in Reanimated
-
-    // @ts-ignore web implementation has still not been updated after the rewrite,
-    // this will be addressed once the web implementation updates are ready
-    requestAnimationFrameImpl(worklet);
-  }
-
-  executeOnUIRuntimeSync(): never {
-    throw new WorkletsError(
-      '`executeOnUIRuntimeSync` is not available in JSWorklets.'
-    );
-  }
-
-  createWorkletRuntime(): never {
-    throw new WorkletsError(
-      'createWorkletRuntime is not available in JSWorklets.'
-    );
-  }
-
-  scheduleOnRuntime(): never {
-    throw new WorkletsError(
-      'scheduleOnRuntime is not available in JSWorklets.'
-    );
-  }
-
-  createSynchronizable(): never {
-    throw new WorkletsError(
-      'createSynchronizable should never be called in JSWorklets.'
-    );
-  }
-
-  synchronizableGetDirty(): never {
-    throw new WorkletsError(
-      'synchronizableGetDirty should never be called in JSWorklets.'
-    );
-  }
-
-  synchronizableGetBlocking(): never {
-    throw new WorkletsError(
-      'synchronizableGetBlocking should never be called in JSWorklets.'
-    );
-  }
-
-  synchronizableSetBlocking(): never {
-    throw new WorkletsError(
-      'synchronizableSetBlocking should never be called in JSWorklets.'
-    );
-  }
-
-  synchronizableLock(): never {
-    throw new WorkletsError(
-      'synchronizableLock should never be called in JSWorklets.'
-    );
-  }
-
-  synchronizableUnlock(): never {
-    throw new WorkletsError(
-      'synchronizableUnlock should never be called in JSWorklets.'
-    );
-  }
-
-  reportFatalErrorOnJS(): never {
-    throw new WorkletsError(
-      'reportFatalErrorOnJS should never be called in JSWorklets.'
-    );
-  }
-
-  getStaticFeatureFlag(): boolean {
-    // mock implementation
-    return false;
-  }
-
-  setDynamicFeatureFlag() {
-    // noop
-  }
-}

package/src/WorkletsModule/NativeWorklets.ts

@@ -1,256 +0,0 @@
-'use strict';
-
-import { RuntimeKind } from '../runtimeKind';
-import { WorkletsTurboModule } from '../specs';
-import type { SynchronizableRef } from '../synchronizable';
-import { checkCppVersion } from '../utils/checkCppVersion';
-import { jsVersion } from '../utils/jsVersion';
-import { WorkletsError } from '../WorkletsError';
-import type { SerializableRef, WorkletRuntime } from '../workletTypes';
-import type {
-  IWorkletsModule,
-  WorkletsModuleProxy,
-} from './workletsModuleProxy';
-
-export function createNativeWorkletsModule(): IWorkletsModule {
-  return new NativeWorklets();
-}
-
-class NativeWorklets implements IWorkletsModule {
-  #workletsModuleProxy: WorkletsModuleProxy;
-  #serializableUndefined: SerializableRef<undefined>;
-  #serializableNull: SerializableRef<null>;
-  #serializableTrue: SerializableRef<boolean>;
-  #serializableFalse: SerializableRef<boolean>;
-
-  constructor() {
-    globalThis._WORKLETS_VERSION_JS = jsVersion;
-    if (
-      global.__workletsModuleProxy === undefined &&
-      globalThis.__RUNTIME_KIND === RuntimeKind.ReactNative
-    ) {
-      WorkletsTurboModule?.installTurboModule();
-    }
-    if (global.__workletsModuleProxy === undefined) {
-      throw new WorkletsError(
-        `Native part of Worklets doesn't seem to be initialized.
-See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#native-part-of-worklets-doesnt-seem-to-be-initialized for more details.`
-      );
-    }
-    if (__DEV__) {
-      checkCppVersion();
-    }
-    this.#workletsModuleProxy = global.__workletsModuleProxy;
-    this.#serializableNull = this.#workletsModuleProxy.createSerializableNull();
-    this.#serializableUndefined =
-      this.#workletsModuleProxy.createSerializableUndefined();
-    this.#serializableTrue =
-      this.#workletsModuleProxy.createSerializableBoolean(true);
-    this.#serializableFalse =
-      this.#workletsModuleProxy.createSerializableBoolean(false);
-  }
-
-  createSerializable<TValue>(
-    value: TValue,
-    shouldPersistRemote: boolean,
-    nativeStateSource?: object
-  ) {
-    return this.#workletsModuleProxy.createSerializable(
-      value,
-      shouldPersistRemote,
-      nativeStateSource
-    );
-  }
-
-  createSerializableImport<TValue>(
-    from: string,
-    to: string
-  ): SerializableRef<TValue> {
-    return this.#workletsModuleProxy.createSerializableImport(from, to);
-  }
-
-  createSerializableString(str: string) {
-    return this.#workletsModuleProxy.createSerializableString(str);
-  }
-
-  createSerializableNumber(num: number) {
-    return this.#workletsModuleProxy.createSerializableNumber(num);
-  }
-
-  createSerializableBoolean(bool: boolean) {
-    return bool ? this.#serializableTrue : this.#serializableFalse;
-  }
-
-  createSerializableBigInt(bigInt: bigint) {
-    return this.#workletsModuleProxy.createSerializableBigInt(bigInt);
-  }
-
-  createSerializableUndefined() {
-    return this.#serializableUndefined;
-  }
-
-  createSerializableNull() {
-    return this.#serializableNull;
-  }
-
-  createSerializableTurboModuleLike<
-    TProps extends object,
-    TProto extends object,
-  >(props: TProps, proto: TProto): SerializableRef<TProps> {
-    return this.#workletsModuleProxy.createSerializableTurboModuleLike(
-      props,
-      proto
-    );
-  }
-
-  createSerializableObject<T extends object>(
-    obj: T,
-    shouldRetainRemote: boolean,
-    nativeStateSource?: object
-  ): SerializableRef<T> {
-    return this.#workletsModuleProxy.createSerializableObject(
-      obj,
-      shouldRetainRemote,
-      nativeStateSource
-    );
-  }
-
-  createSerializableHostObject<T extends object>(obj: T) {
-    return this.#workletsModuleProxy.createSerializableHostObject(obj);
-  }
-
-  createSerializableArray(array: unknown[], shouldRetainRemote: boolean) {
-    return this.#workletsModuleProxy.createSerializableArray(
-      array,
-      shouldRetainRemote
-    );
-  }
-
-  createSerializableMap<TKey, TValue>(
-    keys: TKey[],
-    values: TValue[]
-  ): SerializableRef<Map<TKey, TValue>> {
-    return this.#workletsModuleProxy.createSerializableMap(keys, values);
-  }
-
-  createSerializableSet<TValues>(
-    values: TValues[]
-  ): SerializableRef<Set<TValues>> {
-    return this.#workletsModuleProxy.createSerializableSet(values);
-  }
-
-  createSerializableInitializer(obj: object) {
-    return this.#workletsModuleProxy.createSerializableInitializer(obj);
-  }
-
-  createSerializableFunction<TArgs extends unknown[], TReturn>(
-    func: (...args: TArgs) => TReturn
-  ) {
-    return this.#workletsModuleProxy.createSerializableFunction(func);
-  }
-
-  createSerializableWorklet(worklet: object, shouldPersistRemote: boolean) {
-    return this.#workletsModuleProxy.createSerializableWorklet(
-      worklet,
-      shouldPersistRemote
-    );
-  }
-
-  scheduleOnUI<TValue>(serializable: SerializableRef<TValue>) {
-    return this.#workletsModuleProxy.scheduleOnUI(serializable);
-  }
-
-  executeOnUIRuntimeSync<TValue, TReturn>(
-    serializable: SerializableRef<TValue>
-  ): TReturn {
-    return this.#workletsModuleProxy.executeOnUIRuntimeSync(serializable);
-  }
-
-  createWorkletRuntime(
-    name: string,
-    initializer: SerializableRef<() => void>,
-    useDefaultQueue: boolean,
-    customQueue: object | undefined,
-    enableEventLoop: boolean
-  ) {
-    return this.#workletsModuleProxy.createWorkletRuntime(
-      name,
-      initializer,
-      useDefaultQueue,
-      customQueue,
-      enableEventLoop
-    );
-  }
-
-  scheduleOnRuntime<T>(
-    workletRuntime: WorkletRuntime,
-    serializableWorklet: SerializableRef<T>
-  ) {
-    return this.#workletsModuleProxy.scheduleOnRuntime(
-      workletRuntime,
-      serializableWorklet
-    );
-  }
-
-  createSynchronizable<TValue>(value: TValue): SynchronizableRef<TValue> {
-    return this.#workletsModuleProxy.createSynchronizable(value);
-  }
-
-  synchronizableGetDirty<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>
-  ): TValue {
-    return this.#workletsModuleProxy.synchronizableGetDirty(synchronizableRef);
-  }
-
-  synchronizableGetBlocking<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>
-  ): TValue {
-    return this.#workletsModuleProxy.synchronizableGetBlocking(
-      synchronizableRef
-    );
-  }
-
-  synchronizableSetBlocking<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>,
-    value: SerializableRef<TValue>
-  ) {
-    return this.#workletsModuleProxy.synchronizableSetBlocking(
-      synchronizableRef,
-      value
-    );
-  }
-
-  synchronizableLock<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>
-  ): void {
-    return this.#workletsModuleProxy.synchronizableLock(synchronizableRef);
-  }
-
-  synchronizableUnlock<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>
-  ): void {
-    return this.#workletsModuleProxy.synchronizableUnlock(synchronizableRef);
-  }
-
-  reportFatalErrorOnJS(
-    message: string,
-    stack: string,
-    name: string,
-    jsEngine: string
-  ) {
-    return this.#workletsModuleProxy.reportFatalErrorOnJS(
-      message,
-      stack,
-      name,
-      jsEngine
-    );
-  }
-
-  getStaticFeatureFlag(name: string): boolean {
-    return this.#workletsModuleProxy.getStaticFeatureFlag(name);
-  }
-
-  setDynamicFeatureFlag(name: string, value: boolean) {
-    this.#workletsModuleProxy.setDynamicFeatureFlag(name, value);
-  }
-}

package/src/WorkletsModule/index.ts

@@ -1,7 +0,0 @@
-'use strict';
-
-export { WorkletsModule } from './workletsModuleInstance';
-export type {
-  IWorkletsModule,
-  WorkletsModuleProxy,
-} from './workletsModuleProxy';

package/src/WorkletsModule/workletsModuleInstance.ts

@@ -1,9 +0,0 @@
-'use strict';
-
-import { SHOULD_BE_USE_WEB } from '../PlatformChecker';
-import { createJSWorkletsModule } from './JSWorklets';
-import { createNativeWorkletsModule } from './NativeWorklets';
-
-export const WorkletsModule = SHOULD_BE_USE_WEB
-  ? createJSWorkletsModule()
-  : createNativeWorkletsModule();

package/src/WorkletsModule/workletsModuleInstance.web.ts

@@ -1,5 +0,0 @@
-'use strict';
-
-import { createJSWorkletsModule } from './JSWorklets';
-
-export const WorkletsModule = createJSWorkletsModule();

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