react-native-reanimated 3.0.0 → 3.0.2

package/react-native-reanimated.d.ts

@@ -4,7 +4,6 @@
 declare module 'react-native-reanimated' {
   import {
     ComponentClass,
-    ReactNode,
     Component,
     RefObject,
     FunctionComponent,
@@ -58,74 +57,14 @@ declare module 'react-native-reanimated' {
     import('./lib/types/lib/reanimated2/commonTypes').MeasuredDimensions;
 
   namespace Animated {
-    type Nullable<T> = T | null | undefined;
-    class AnimatedNode<T> {
-      constructor(
-        nodeConfig: object,
-        inputNodes?: ReadonlyArray<AnimatedNode<any>>
-      );
-
-      isNativelyInitialized(): boolean;
-      /**
-       * ' __value' is not available at runtime on AnimatedNode<T>. It is
-       * necessary to have some discriminating property on a type to know that
-       * an AnimatedNode<number> and AnimatedNode<string> are not compatible types.
-       */
-      ' __value': T;
-    }
-    class AnimatedClock extends AnimatedNode<number> {
-      constructor();
-    }
-
-    export enum Extrapolate {
-      EXTEND = 'extend',
-      CLAMP = 'clamp',
-      IDENTITY = 'identity',
-    }
-
-    type ExtrapolateParameter =
-      | Extrapolate
-      | { extrapolateLeft?: Extrapolate; extrapolateRight?: Extrapolate };
-
-    interface InterpolationConfig {
-      inputRange: ReadonlyArray<Adaptable<number>>;
-      outputRange: ReadonlyArray<Adaptable<number | string>>;
-      extrapolate?: ExtrapolateParameter;
-      extrapolateLeft?: Extrapolate;
-      extrapolateRight?: Extrapolate;
-    }
     type Value = string | number | boolean;
-    class AnimatedValue<T extends Value> extends AnimatedNode<T> {
-      constructor(value?: T);
-
-      setValue(value: Adaptable<T>): void;
-
-      interpolate(config: InterpolationConfig): AnimatedNode<number>;
-    }
-    export interface AnimationState {
-      finished: AnimatedValue<number>;
-      position: AnimatedValue<number>;
-      time: AnimatedValue<number>;
-    }
 
     export type SharedValue<T> = { value: T };
     export type DerivedValue<T> = Readonly<SharedValue<T>>;
-    export type Mapping = { [key: string]: Mapping } | Adaptable<any>;
     export type Adaptable<T> =
       | T
-      | AnimatedNode<T>
-      | ReadonlyArray<T | AnimatedNode<T> | ReadonlyArray<T | AnimatedNode<T>>>
+      | ReadonlyArray<T | ReadonlyArray<T>>
       | SharedValue<T>;
-    type BinaryOperator<T = number> = (
-      left: Adaptable<number>,
-      right: Adaptable<number>
-    ) => AnimatedNode<T>;
-    type UnaryOperator = (value: Adaptable<number>) => AnimatedNode<number>;
-    type MultiOperator<T = number> = (
-      a: Adaptable<number>,
-      b: Adaptable<number>,
-      ...others: Adaptable<number>[]
-    ) => AnimatedNode<T>;
 
     export type TransformStyleTypes = TransformsStyle['transform'] extends
       | readonly (infer T)[]
@@ -146,13 +85,7 @@ declare module 'react-native-reanimated' {
         ? AnimateStyle<S[K]>
         : S[K] extends ColorValue | undefined
         ? S[K] | number
-        :
-            | S[K]
-            | AnimatedNode<
-                // allow `number` where `string` normally is to support colors
-                S[K] extends ColorValue | undefined ? S[K] | number : S[K]
-              >
-            | SharedValue<AnimatableValue>;
+        : S[K] | SharedValue<AnimatableValue>;
     };
 
     export type StylesOrDefault<T> = 'style' extends keyof T
@@ -160,7 +93,7 @@ declare module 'react-native-reanimated' {
       : Record<string, unknown>;
 
     export type AnimateProps<P extends object> = {
-      [K in keyof Omit<P, 'style'>]: P[K] | AnimatedNode<P[K]> | SharedValue<P[K]>;
+      [K in keyof Omit<P, 'style'>]: P[K] | SharedValue<P[K]>;
     } & {
       style?: StyleProp<AnimateStyle<StylesOrDefault<P>>>;
     } & {
@@ -183,81 +116,7 @@ declare module 'react-native-reanimated' {
       sharedTransitionStyle?: ILayoutAnimationBuilder;
     };
 
-    export interface PhysicsAnimationState extends AnimationState {
-      velocity: AnimatedValue<number>;
-    }
-
-    export type DecayState = PhysicsAnimationState;
-
-    export interface DecayConfig {
-      deceleration: Adaptable<number>;
-    }
-    export interface BackwardCompatibleWrapper {
-      start: (callback?: (data: { finished: boolean }) => any) => void;
-      stop: () => void;
-    }
-
-    export interface TimingState extends AnimationState {
-      frameTime: AnimatedValue<number>;
-    }
-    export type EasingNodeFunction = (
-      value: Adaptable<number>
-    ) => AnimatedNode<number>;
     export type EasingFunction = (value: number) => number;
-    export interface TimingConfig {
-      toValue: Adaptable<number>;
-      duration: Adaptable<number>;
-      easing: EasingNodeFunction;
-    }
-
-    export type SpringState = PhysicsAnimationState;
-
-    export interface SpringConfig {
-      damping: Adaptable<number>;
-      mass: Adaptable<number>;
-      stiffness: Adaptable<number>;
-      overshootClamping: Adaptable<number> | boolean;
-      restSpeedThreshold: Adaptable<number>;
-      restDisplacementThreshold: Adaptable<number>;
-      toValue: Adaptable<number>;
-    }
-    interface SpringConfigWithOrigamiTensionAndFriction {
-      tension: Adaptable<number>;
-      mass: Adaptable<number>;
-      friction: Adaptable<number>;
-      overshootClamping: Adaptable<number> | boolean;
-      restSpeedThreshold: Adaptable<number>;
-      restDisplacementThreshold: Adaptable<number>;
-      toValue: Adaptable<number>;
-    }
-
-    interface SpringConfigWithBouncinessAndSpeed {
-      bounciness: Adaptable<number>;
-      mass: Adaptable<number>;
-      speed: Adaptable<number>;
-      overshootClamping: Adaptable<number> | boolean;
-      restSpeedThreshold: Adaptable<number>;
-      restDisplacementThreshold: Adaptable<number>;
-      toValue: Adaptable<number>;
-    }
-
-    type SpringUtils = {
-      makeDefaultConfig: () => SpringConfig;
-      makeConfigFromBouncinessAndSpeed: (
-        prevConfig: SpringConfigWithBouncinessAndSpeed
-      ) => SpringConfig;
-      makeConfigFromOrigamiTensionAndFriction: (
-        prevConfig: SpringConfigWithOrigamiTensionAndFriction
-      ) => SpringConfig;
-    };
-
-    export const SpringUtils: SpringUtils;
-
-    type CodeProps = {
-      exec?: AnimatedNode<number>;
-      children?: () => AnimatedNode<number>;
-      dependencies?: Array<any>;
-    };
 
     // components
     export class View extends Component<AnimateProps<ViewProps>> {
@@ -280,8 +139,6 @@ declare module 'react-native-reanimated' {
     }
     // eslint-disable-next-line @typescript-eslint/no-empty-interface
     export interface ScrollView extends ReactNativeScrollView {}
-
-    export class Code extends Component<CodeProps> {}
     export interface FlatListPropsWithLayout<T> extends FlatListProps<T> {
       itemLayoutAnimation?: ILayoutAnimationBuilder;
     }
@@ -305,164 +162,6 @@ declare module 'react-native-reanimated' {
       options?: Options<P>
     ): FunctionComponent<AnimateProps<P>>;
 
-    // classes
-    export {
-      AnimatedClock as Clock,
-      AnimatedNode as Node,
-      AnimatedValue as Value,
-    };
-
-    // base operations
-    export const add: MultiOperator;
-    export const sub: MultiOperator;
-    export const multiply: MultiOperator;
-    export const divide: MultiOperator;
-    export const pow: MultiOperator;
-    export const modulo: MultiOperator;
-    export const sqrt: UnaryOperator;
-    export const log: UnaryOperator;
-    export const sin: UnaryOperator;
-    export const cos: UnaryOperator;
-    export const tan: UnaryOperator;
-    export const acos: UnaryOperator;
-    export const asin: UnaryOperator;
-    export const atan: UnaryOperator;
-    export const exp: UnaryOperator;
-    export const round: UnaryOperator;
-    export const floor: UnaryOperator;
-    export const ceil: UnaryOperator;
-    export const lessThan: BinaryOperator<0 | 1>;
-    export const eq: BinaryOperator<0 | 1>;
-    export const greaterThan: BinaryOperator<0 | 1>;
-    export const lessOrEq: BinaryOperator<0 | 1>;
-    export const greaterOrEq: BinaryOperator<0 | 1>;
-    export const neq: BinaryOperator<0 | 1>;
-    export const and: MultiOperator<0 | 1>;
-    export const or: MultiOperator<0 | 1>;
-    export function proc<T extends (Adaptable<Value> | undefined)[]>(
-      func: (...args: T) => AnimatedNode<number>
-    ): typeof func;
-    export function defined(value: Adaptable<any>): AnimatedNode<0 | 1>;
-    export function not(value: Adaptable<any>): AnimatedNode<0 | 1>;
-    export function set<T extends Value>(
-      valueToBeUpdated: AnimatedValue<T>,
-      sourceNode: Adaptable<T>
-    ): AnimatedNode<T>;
-    export function concat(
-      ...args: Array<Adaptable<string> | Adaptable<number>>
-    ): AnimatedNode<string>;
-    export function cond<T1 extends Value = number, T2 extends Value = number>(
-      conditionNode: Adaptable<number>,
-      ifNode: Adaptable<T1>,
-      elseNode?: Adaptable<T2>
-    ): AnimatedNode<T1 | T2>;
-    export function block<T1 extends Value = number, T2 extends Value = any>(
-      items: ReadonlyArray<Adaptable<T2>>
-    ): AnimatedNode<T1>;
-    export function call<T>(
-      args: ReadonlyArray<T | AnimatedNode<T>>,
-      callback: (args: ReadonlyArray<T>) => void
-    ): AnimatedNode<0>;
-    export function debug<T>(
-      message: string,
-      value: AnimatedNode<T>
-    ): AnimatedNode<T>;
-    export function onChange(
-      value: Adaptable<number>,
-      action: Adaptable<number>
-    ): AnimatedNode<number>;
-    export function startClock(clock: AnimatedClock): AnimatedNode<0>;
-    export function stopClock(clock: AnimatedClock): AnimatedNode<0>;
-    export function clockRunning(clock: AnimatedClock): AnimatedNode<0 | 1>;
-    // the return type for `event` is a lie, but it's the same lie that
-    // react-native makes within Animated
-    type EventArgFunc<T> = (arg: T) => AnimatedNode<number>;
-    type EventMapping<T> = T extends object
-      ? { [K in keyof T]?: EventMapping<T[K]> | EventArgFunc<T[K]> }
-      : Adaptable<T> | EventArgFunc<T>;
-    type EventMappingArray<T> = T extends Array<any>
-      ? { [I in keyof T]: EventMapping<T[I]> }
-      : [EventMapping<T>];
-    export function event<T>(
-      argMapping: T extends never
-        ? ReadonlyArray<Mapping>
-        : Readonly<EventMappingArray<T>>,
-      config?: {}
-    ): (...args: any[]) => void;
-
-    // derived operations
-    export function abs(value: Adaptable<number>): AnimatedNode<number>;
-    export function acc(value: Adaptable<number>): AnimatedNode<number>;
-    export function color(
-      r: Adaptable<number>,
-      g: Adaptable<number>,
-      b: Adaptable<number>,
-      a?: Adaptable<number>
-    ): AnimatedNode<number | string>;
-    export function diff(value: Adaptable<number>): AnimatedNode<number>;
-    export function diffClamp(
-      value: Adaptable<number>,
-      minVal: Adaptable<number>,
-      maxVal: Adaptable<number>
-    ): AnimatedNode<number>;
-    export function interpolateNode(
-      value: Adaptable<number>,
-      config: InterpolationConfig
-    ): AnimatedNode<number>;
-    export function interpolateColors<T extends string | number>(
-      animationValue: Adaptable<number>,
-      {
-        inputRange,
-        outputColorRange,
-      }: {
-        inputRange: ReadonlyArray<Adaptable<number>>;
-        outputColorRange: ReadonlyArray<Adaptable<T>>;
-      }
-    ): AnimatedNode<T>;
-    export const max: BinaryOperator;
-    export const min: BinaryOperator;
-
-    // animations
-    export function decay(
-      clock: AnimatedClock,
-      state: DecayState,
-      config: DecayConfig
-    ): AnimatedNode<number>;
-    export function timing(
-      clock: AnimatedClock,
-      state: TimingState,
-      config: TimingConfig
-    ): AnimatedNode<number>;
-    export function spring(
-      clock: AnimatedClock,
-      state: SpringState,
-      config: SpringConfig
-    ): AnimatedNode<number>;
-    // backward compatible API
-    export function spring(
-      node: AnimatedNode<number>,
-      config: SpringConfig
-    ): BackwardCompatibleWrapper;
-    export function timing(
-      node: AnimatedNode<number>,
-      config: TimingConfig
-    ): BackwardCompatibleWrapper;
-    export function decay(
-      node: AnimatedNode<number>,
-      config: DecayConfig
-    ): BackwardCompatibleWrapper;
-
-    // hooks
-    export function useCode(
-      exec: () =>
-        | Nullable<AnimatedNode<number>[] | AnimatedNode<number>>
-        | boolean,
-      deps: Array<any>
-    ): void;
-    export function useValue<T extends Value>(
-      initialValue: T
-    ): AnimatedValue<T>;
-
     // configuration
     export function addWhitelistedNativeProps(props: {
       [key: string]: true;
@@ -475,7 +174,6 @@ declare module 'react-native-reanimated' {
   export type SharedValue<T> = Animated.SharedValue<T>;
   export type AnimateStyle<S> = Animated.AnimateStyle<S>;
   export type DerivedValue<T> = Animated.DerivedValue<T>;
-  export type Mapping = Animated.Mapping;
   export type Adaptable<T> = Animated.Adaptable<T>;
   export type TransformStyleTypes = Animated.TransformStyleTypes;
   export type AdaptTransforms<T> = Animated.AdaptTransforms<T>;
@@ -527,6 +225,13 @@ declare module 'react-native-reanimated' {
 
   export type SensorValue3D = SharedValue<Value3D>;
 
+  export enum InterfaceOrientation {
+    ROTATION_0 = 0,
+    ROTATION_90 = 90,
+    ROTATION_180 = 180,
+    ROTATION_270 = 270,
+  }
+
   export type ValueRotation = {
     qw: number;
     qx: number;
@@ -1117,32 +822,6 @@ declare module 'react-native-reanimated' {
   export class RollInRight extends ComplexAnimationBuilder {}
   export class RollOutLeft extends ComplexAnimationBuilder {}
   export class RollOutRight extends ComplexAnimationBuilder {}
-  interface EasingNodeStatic {
-    linear: Animated.EasingNodeFunction;
-    ease: Animated.EasingNodeFunction;
-    quad: Animated.EasingNodeFunction;
-    cubic: Animated.EasingNodeFunction;
-    poly(n: Animated.Adaptable<number>): Animated.EasingNodeFunction;
-    sin: Animated.EasingNodeFunction;
-    circle: Animated.EasingNodeFunction;
-    exp: Animated.EasingNodeFunction;
-    elastic(
-      bounciness?: Animated.Adaptable<number>
-    ): Animated.EasingNodeFunction;
-    back(s?: Animated.Adaptable<number>): Animated.EasingNodeFunction;
-    bounce: Animated.EasingNodeFunction;
-    bezier(
-      x1: number,
-      y1: number,
-      x2: number,
-      y2: number
-    ): Animated.EasingNodeFunction;
-    in(easing: Animated.EasingNodeFunction): Animated.EasingNodeFunction;
-    out(easing: Animated.EasingNodeFunction): Animated.EasingNodeFunction;
-    inOut(easing: Animated.EasingNodeFunction): Animated.EasingNodeFunction;
-  }
-
-  export const EasingNode: EasingNodeStatic;
 
   interface EasingStatic {
     linear: Animated.EasingFunction;
@@ -1175,106 +854,10 @@ declare module 'react-native-reanimated' {
 
   export const Easing: EasingStatic;
 
-  export interface TransitioningViewProps extends ViewProps {
-    transition: ReactNode;
-  }
-
-  export class TransitioningView extends Component<TransitioningViewProps> {
-    animateNextTransition(): void;
-  }
-
-  export class Transitioning extends Component {
-    static View: typeof TransitioningView;
-  }
-
-  export interface TransitionProps {
-    delayMs?: number;
-    durationMs?: number;
-    interpolation?: 'linear' | 'easeIn' | 'easeOut' | 'easeInOut';
-    propagation?: 'top' | 'bottom' | 'left' | 'right';
-  }
-
-  export interface TransitionInOutProps extends TransitionProps {
-    type?:
-      | 'fade'
-      | 'scale'
-      | 'slide-top'
-      | 'slide-bottom'
-      | 'slide-right'
-      | 'slide-left';
-  }
-  export class Transition extends Component {
-    static In: ComponentClass<TransitionInOutProps>;
-    static Out: ComponentClass<TransitionInOutProps>;
-    static Change: ComponentClass<TransitionProps>;
-    static Together: ComponentClass<{}>;
-    static Sequence: ComponentClass<{}>;
-  }
-
-  export class Clock extends Animated.Clock {}
-  export class Value<
-    T extends string | number | boolean
-  > extends Animated.Value<T> {}
-  export class Node<T> extends Animated.Node<T> {}
-  export const add: typeof Animated.add;
-  export const sub: typeof Animated.sub;
-  export const multiply: typeof Animated.multiply;
-  export const divide: typeof Animated.divide;
-  export const pow: typeof Animated.pow;
-  export const modulo: typeof Animated.modulo;
-  export const sqrt: typeof Animated.sqrt;
-  export const log: typeof Animated.log;
-  export const sin: typeof Animated.sin;
-  export const cos: typeof Animated.cos;
-  export const exp: typeof Animated.exp;
-  export const round: typeof Animated.round;
-  export const lessThan: typeof Animated.lessThan;
-  export const eq: typeof Animated.eq;
-  export const greaterThan: typeof Animated.greaterThan;
-  export const lessOrEq: typeof Animated.lessOrEq;
-  export const greaterOrEq: typeof Animated.greaterOrEq;
-  export const neq: typeof Animated.neq;
-  export const and: typeof Animated.and;
-  export const or: typeof Animated.or;
-  export const defined: typeof Animated.defined;
-  export const not: typeof Animated.not;
-  export const tan: typeof Animated.tan;
-  export const acos: typeof Animated.acos;
-  export const asin: typeof Animated.asin;
-  export const atan: typeof Animated.atan;
-  export const proc: typeof Animated.proc;
-  export const block: typeof Animated.block;
-  export const concat: typeof Animated.concat;
-  export const event: typeof Animated.event;
-  export const call: typeof Animated.call;
-  export const debug: typeof Animated.debug;
-  export const clockRunning: typeof Animated.clockRunning;
-  export const stopClock: typeof Animated.stopClock;
-  export const startClock: typeof Animated.startClock;
-  export const set: typeof Animated.set;
-  export const cond: typeof Animated.cond;
-  export const abs: typeof Animated.abs;
-  export const acc: typeof Animated.acc;
-  export const color: typeof Animated.color;
-  export const interpolateColors: typeof Animated.interpolateColors;
-  export const diff: typeof Animated.diff;
-  export const diffClamp: typeof Animated.diffClamp;
-  export const interpolateNode: typeof Animated.interpolateNode;
-  export const Extrapolate: typeof Animated.Extrapolate;
-  export const max: typeof Animated.max;
-  export const min: typeof Animated.min;
-  export const onChange: typeof Animated.onChange;
-  export const floor: typeof Animated.floor;
-  export const ceil: typeof Animated.ceil;
-  export const useCode: typeof Animated.useCode;
-  export const decay: typeof Animated.decay;
-  export const timing: typeof Animated.timing;
-  export const spring: typeof Animated.spring;
-  export const SpringUtils: typeof Animated.SpringUtils;
-  export const useValue: typeof Animated.useValue;
-  export const ReverseAnimation: typeof Animated.ReverseAnimation;
   export function enableLayoutAnimations(flag: boolean): void;
 
+  export const Extrapolate: typeof Extrapolation;
+
   type AnimationFactoryType = (values: LayoutAnimationsValues) => StyleProps;
 
   export class SharedTransition implements ILayoutAnimationBuilder {

package/src/createAnimatedComponent.tsx

@@ -116,10 +116,16 @@ const has = <K extends string>(
 };
 
 function isInlineStyleTransform(transform: any): boolean {
+  if (!transform) {
+    return false;
+  }
   return transform.some((t: Record<string, any>) => hasInlineStyles(t));
 }
 
 function hasInlineStyles(style: StyleProps): boolean {
+  if (!style) {
+    return false;
+  }
   return Object.keys(style).some((key) => {
     const styleValue = style[key];
     return (
@@ -139,6 +145,9 @@ function extractSharedValuesMapFromProps(
     if (key === 'style') {
       const styles = flattenArray<StyleProps>(props.style ?? []);
       styles.forEach((style) => {
+        if (!style) {
+          return;
+        }
         for (const [key, styleValue] of Object.entries(style)) {
           if (isSharedValue(styleValue)) {
             inlineProps[key] = styleValue;

package/src/reanimated2/hook/useAnimatedSensor.ts

@@ -7,6 +7,7 @@ import {
   ValueRotation,
   IOSReferenceFrame,
 } from '../commonTypes';
+import { flushImmediates } from '../threads';
 
 export type SensorConfig = {
   interval: number | 'auto';
@@ -144,6 +145,7 @@ export function useAnimatedSensor(
           }
         }
         sensorData.value = data;
+        flushImmediates();
       }
     );
 

package/src/reanimated2/initializers.ts

@@ -128,7 +128,7 @@ function setupRequestAnimationFrame() {
         global.__frameTimestamp = undefined;
       });
     }
-    // Reanimated currently does not support cancelling calbacks requested with
+    // Reanimated currently does not support cancelling callbacks requested with
     // requestAnimationFrame. We return -1 as identifier which isn't in line
     // with the spec but it should give users better clue in case they actually
     // attempt to store the value returned from rAF and use it for cancelling.

package/src/reanimated2/layoutReanimation/animationsManager.ts

@@ -88,6 +88,9 @@ function createLayoutAnimationManager() {
     },
     stop(tag: number) {
       const value = mutableValuesForTag.get(tag);
+      if (!value) {
+        return;
+      }
       stopObservingProgress(tag, value, true, true);
     },
   };

package/src/reanimated2/mock.ts

@@ -28,7 +28,7 @@ class BaseAnimationMock {
     return this;
   }
 
-  withCallback(_: (finsihed: boolean) => void) {
+  withCallback(_: (finished: boolean) => void) {
     return this;
   }
 

package/src/reanimated2/platform-specific/checkVersion.ts

@@ -3,7 +3,7 @@
  * 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`
  */
-const jsVersion = '3.0.0';
+const jsVersion = '3.0.2';
 
 /**
  * Checks that native and js versions of reanimated match.

package/src/reanimated2/threads.ts

@@ -7,26 +7,27 @@ import {
 } from './shareables';
 
 const IS_JEST = isJest();
+const IS_WEB = shouldBeUseWeb();
 
 let _runOnUIQueue: Array<[ComplexWorkletFunction<any[], any>, any[]]> = [];
 
 export function setupSetImmediate() {
   'worklet';
 
-  let immediateCalbacks: Array<() => void> = [];
+  let immediateCallbacks: Array<() => void> = [];
 
   // @ts-ignore – typescript expects this to conform to NodeJS definition and expects the return value to be NodeJS.Immediate which is an object and not a number
   global.setImmediate = (callback: () => void): number => {
-    immediateCalbacks.push(callback);
+    immediateCallbacks.push(callback);
     return -1;
   };
 
   global.__flushImmediates = () => {
-    for (let index = 0; index < immediateCalbacks.length; index += 1) {
+    for (let index = 0; index < immediateCallbacks.length; index += 1) {
       // we use classic 'for' loop because the size of the currentTasks array may change while executing some of the callbacks due to setImmediate calls
-      immediateCalbacks[index]();
+      immediateCallbacks[index]();
     }
-    immediateCalbacks = [];
+    immediateCallbacks = [];
   };
 }
 
@@ -49,10 +50,8 @@ export const flushImmediates = shouldBeUseWeb()
 export function runOnUI<A extends any[], R>(
   worklet: ComplexWorkletFunction<A, R>
 ): (...args: A) => void {
-  if (__DEV__ && !shouldBeUseWeb()) {
-    if (worklet.__workletHash === undefined) {
-      throw new Error('runOnUI() can only be used on worklets');
-    }
+  if (__DEV__ && !IS_WEB && worklet.__workletHash === undefined) {
+    throw new Error('runOnUI() can only be used on worklets');
   }
   return (...args) => {
     if (IS_JEST) {
@@ -98,10 +97,8 @@ export function runOnUI<A extends any[], R>(
 export function runOnUIImmediately<A extends any[], R>(
   worklet: ComplexWorkletFunction<A, R>
 ): (...args: A) => void {
-  if (__DEV__) {
-    if (worklet.__workletHash === undefined) {
-      throw new Error('runOnUI() can only be used on worklets');
-    }
+  if (__DEV__ && !IS_WEB && worklet.__workletHash === undefined) {
+    throw new Error('runOnUI() can only be used on worklets');
   }
   return (...args) => {
     NativeReanimatedModule.scheduleOnUI(

package/src/reanimated2/utils.ts

@@ -30,5 +30,5 @@ export function getRelativeCoords(
 
 export function isSharedValue<T>(value: any): value is SharedValue<T> {
   'worklet';
-  return typeof value === 'object' && value._isReanimatedSharedValue === true;
+  return value?._isReanimatedSharedValue === true;
 }