react-native-reanimated 2.9.0 → 3.0.0-rc.1

package/lib/reanimated2/animation/util.js

@@ -1,180 +0,0 @@
-/* global _WORKLET */
-import { convertToHSVA, isColor, toRGBA } from '../Colors';
-import NativeReanimatedModule from '../NativeReanimated';
-let IN_STYLE_UPDATER = false;
-export function initialUpdaterRun(updater) {
-    IN_STYLE_UPDATER = true;
-    const result = updater();
-    IN_STYLE_UPDATER = false;
-    return result;
-}
-function recognizePrefixSuffix(value) {
-    'worklet';
-    var _a;
-    if (typeof value === 'string') {
-        const match = value.match(/([A-Za-z]*)(-?\d*\.?\d*)([eE][-+]?[0-9]+)?([A-Za-z%]*)/);
-        if (!match) {
-            throw Error("Couldn't parse animation value. Check if there isn't any typo.");
-        }
-        const prefix = match[1];
-        const suffix = match[4];
-        // number with scientific notation
-        const number = match[2] + ((_a = match[3]) !== null && _a !== void 0 ? _a : '');
-        return { prefix, suffix, strippedValue: parseFloat(number) };
-    }
-    else {
-        return { strippedValue: value };
-    }
-}
-function decorateAnimation(animation) {
-    'worklet';
-    if (animation.isHigherOrder) {
-        return;
-    }
-    const baseOnStart = animation.onStart;
-    const baseOnFrame = animation.onFrame;
-    const animationCopy = Object.assign({}, animation);
-    delete animationCopy.callback;
-    const prefNumberSuffOnStart = (animation, value, timestamp, previousAnimation) => {
-        var _a, _b, _c, _d;
-        // recognize prefix, suffix, and updates stripped value on animation start
-        const { prefix, suffix, strippedValue } = recognizePrefixSuffix(value);
-        animation.__prefix = prefix;
-        animation.__suffix = suffix;
-        animation.strippedCurrent = strippedValue;
-        const { strippedValue: strippedToValue } = recognizePrefixSuffix(animation.toValue);
-        animation.current = strippedValue;
-        animation.startValue = strippedValue;
-        animation.toValue = strippedToValue;
-        if (previousAnimation && previousAnimation !== animation) {
-            previousAnimation.current = previousAnimation.strippedCurrent;
-        }
-        baseOnStart(animation, strippedValue, timestamp, previousAnimation);
-        animation.current =
-            ((_a = animation.__prefix) !== null && _a !== void 0 ? _a : '') +
-                animation.current +
-                ((_b = animation.__suffix) !== null && _b !== void 0 ? _b : '');
-        if (previousAnimation && previousAnimation !== animation) {
-            previousAnimation.current =
-                ((_c = previousAnimation.__prefix) !== null && _c !== void 0 ? _c : '') +
-                    previousAnimation.current +
-                    ((_d = previousAnimation.__suffix) !== null && _d !== void 0 ? _d : '');
-        }
-    };
-    const prefNumberSuffOnFrame = (animation, timestamp) => {
-        var _a, _b;
-        animation.current = animation.strippedCurrent;
-        const res = baseOnFrame(animation, timestamp);
-        animation.strippedCurrent = animation.current;
-        animation.current =
-            ((_a = animation.__prefix) !== null && _a !== void 0 ? _a : '') +
-                animation.current +
-                ((_b = animation.__suffix) !== null && _b !== void 0 ? _b : '');
-        return res;
-    };
-    const tab = ['H', 'S', 'V', 'A'];
-    const colorOnStart = (animation, value, timestamp, previousAnimation) => {
-        let HSVAValue;
-        let HSVACurrent;
-        let HSVAToValue;
-        const res = [];
-        if (isColor(value)) {
-            HSVACurrent = convertToHSVA(animation.current);
-            HSVAValue = convertToHSVA(value);
-            if (animation.toValue) {
-                HSVAToValue = convertToHSVA(animation.toValue);
-            }
-        }
-        tab.forEach((i, index) => {
-            animation[i] = Object.assign({}, animationCopy);
-            animation[i].current = HSVACurrent[index];
-            animation[i].toValue = HSVAToValue ? HSVAToValue[index] : undefined;
-            animation[i].onStart(animation[i], HSVAValue[index], timestamp, previousAnimation ? previousAnimation[i] : undefined);
-            res.push(animation[i].current);
-        });
-        animation.current = toRGBA(res);
-    };
-    const colorOnFrame = (animation, timestamp) => {
-        const HSVACurrent = convertToHSVA(animation.current);
-        const res = [];
-        let finished = true;
-        tab.forEach((i, index) => {
-            animation[i].current = HSVACurrent[index];
-            // @ts-ignore: disable-next-line
-            finished &= animation[i].onFrame(animation[i], timestamp);
-            res.push(animation[i].current);
-        });
-        animation.current = toRGBA(res);
-        return finished;
-    };
-    const arrayOnStart = (animation, value, timestamp, previousAnimation) => {
-        value.forEach((v, i) => {
-            animation[i] = Object.assign({}, animationCopy);
-            animation[i].current = v;
-            animation[i].toValue = animation.toValue[i];
-            animation[i].onStart(animation[i], v, timestamp, previousAnimation ? previousAnimation[i] : undefined);
-        });
-        animation.current = value;
-    };
-    const arrayOnFrame = (animation, timestamp) => {
-        let finished = true;
-        animation.current.forEach((v, i) => {
-            // @ts-ignore: disable-next-line
-            finished &= animation[i].onFrame(animation[i], timestamp);
-            animation.current[i] = animation[i].current;
-        });
-        return finished;
-    };
-    animation.onStart = (animation, value, timestamp, previousAnimation) => {
-        if (isColor(value)) {
-            colorOnStart(animation, value, timestamp, previousAnimation);
-            animation.onFrame = colorOnFrame;
-            return;
-        }
-        else if (Array.isArray(value)) {
-            arrayOnStart(animation, value, timestamp, previousAnimation);
-            animation.onFrame = arrayOnFrame;
-            return;
-        }
-        else if (typeof value === 'string') {
-            prefNumberSuffOnStart(animation, value, timestamp, previousAnimation);
-            animation.onFrame = prefNumberSuffOnFrame;
-            return;
-        }
-        baseOnStart(animation, value, timestamp, previousAnimation);
-    };
-}
-export function defineAnimation(starting, factory) {
-    'worklet';
-    if (IN_STYLE_UPDATER) {
-        return starting;
-    }
-    const create = () => {
-        'worklet';
-        const animation = factory();
-        decorateAnimation(animation);
-        return animation;
-    };
-    if (_WORKLET || !NativeReanimatedModule.native) {
-        return create();
-    }
-    // @ts-ignore: eslint-disable-line
-    return create;
-}
-export function cancelAnimation(sharedValue) {
-    'worklet';
-    // setting the current value cancels the animation if one is currently running
-    sharedValue.value = sharedValue.value; // eslint-disable-line no-self-assign
-}
-// TODO it should work only if there was no animation before.
-export function withStartValue(startValue, animation) {
-    'worklet';
-    return defineAnimation(startValue, () => {
-        'worklet';
-        if (!_WORKLET && typeof animation === 'function') {
-            animation = animation();
-        }
-        animation.current = startValue;
-        return animation;
-    });
-}

package/lib/reanimated2/commonTypes.js

@@ -1 +0,0 @@
-export {};

package/lib/reanimated2/component/FlatList.js

@@ -1,30 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import React from 'react';
-import { FlatList } from 'react-native';
-import ReanimatedView from './View';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedFlatList = createAnimatedComponent(FlatList);
-const createCellRenderer = (itemLayoutAnimation) => {
-    const cellRenderer = (props) => {
-        return (<ReanimatedView layout={itemLayoutAnimation} onLayout={props.onLayout}>
-        {props.children}
-      </ReanimatedView>);
-    };
-    return cellRenderer;
-};
-const ReanimatedFlatlist = (_a) => {
-    var { itemLayoutAnimation } = _a, restProps = __rest(_a, ["itemLayoutAnimation"]);
-    const cellRenderer = React.useMemo(() => createCellRenderer(itemLayoutAnimation), []);
-    return (<AnimatedFlatList {...restProps} CellRendererComponent={cellRenderer}/>);
-};
-export default ReanimatedFlatlist;

package/lib/reanimated2/component/Image.js

@@ -1,4 +0,0 @@
-import { Image } from 'react-native';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedImage = createAnimatedComponent(Image);
-export default AnimatedImage;

package/lib/reanimated2/component/ScrollView.js

@@ -1,4 +0,0 @@
-import { ScrollView } from 'react-native';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedScrollView = createAnimatedComponent(ScrollView);
-export default AnimatedScrollView;

package/lib/reanimated2/component/Text.js

@@ -1,4 +0,0 @@
-import { Text } from 'react-native';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedText = createAnimatedComponent(Text);
-export default AnimatedText;

package/lib/reanimated2/component/View.js

@@ -1,4 +0,0 @@
-import { View } from 'react-native';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedView = createAnimatedComponent(View);
-export default AnimatedView;

package/lib/reanimated2/core.js

@@ -1,268 +0,0 @@
-/* global _WORKLET _getCurrentTime _frameTimestamp _eventTimestamp, _setGlobalConsole */
-import NativeReanimatedModule from './NativeReanimated';
-import { Platform } from 'react-native';
-import { nativeShouldBeMock, shouldBeUseWeb, isWeb } from './PlatformChecker';
-if (global._setGlobalConsole === undefined) {
-    // it can happen when Reanimated plugin wasn't added, but the user uses the only API from version 1
-    global._setGlobalConsole = () => {
-        // noop
-    };
-}
-const testWorklet = () => {
-    'worklet';
-};
-export const checkPluginState = (throwError = true) => {
-    if (!testWorklet.__workletHash && !shouldBeUseWeb()) {
-        if (throwError) {
-            throw new Error("Reanimated 2 failed to create a worklet, maybe you forgot to add Reanimated's babel plugin?");
-        }
-        return false;
-    }
-    return true;
-};
-export const isConfigured = (throwError = false) => {
-    return checkPluginState(throwError);
-};
-export const isConfiguredCheck = () => {
-    if (!isConfigured(true)) {
-        throw new Error('If you want to use Reanimated 2 then go through our installation steps https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation');
-    }
-};
-function pushFrame(frame) {
-    NativeReanimatedModule.pushFrame(frame);
-}
-export function requestFrame(frame) {
-    'worklet';
-    if (NativeReanimatedModule.native) {
-        requestAnimationFrame(frame);
-    }
-    else {
-        pushFrame(frame);
-    }
-}
-global._WORKLET = false;
-global._log = function (s) {
-    console.log(s);
-};
-export function runOnUI(worklet) {
-    return makeShareable(worklet);
-}
-export function makeShareable(value) {
-    isConfiguredCheck();
-    return NativeReanimatedModule.makeShareable(value);
-}
-export function getViewProp(viewTag, propName) {
-    return new Promise((resolve, reject) => {
-        return NativeReanimatedModule.getViewProp(viewTag, propName, (result) => {
-            if (typeof result === 'string' && result.substr(0, 6) === 'error:') {
-                reject(result);
-            }
-            else {
-                resolve(result);
-            }
-        });
-    });
-}
-let _getTimestamp;
-if (nativeShouldBeMock()) {
-    _getTimestamp = () => {
-        return NativeReanimatedModule.getTimestamp();
-    };
-}
-else {
-    _getTimestamp = () => {
-        'worklet';
-        if (_frameTimestamp) {
-            return _frameTimestamp;
-        }
-        if (_eventTimestamp) {
-            return _eventTimestamp;
-        }
-        return _getCurrentTime();
-    };
-}
-export function getTimestamp() {
-    'worklet';
-    if (Platform.OS === 'web') {
-        return NativeReanimatedModule.getTimestamp();
-    }
-    return _getTimestamp();
-}
-function workletValueSetter(value) {
-    'worklet';
-    const previousAnimation = this._animation;
-    if (previousAnimation) {
-        previousAnimation.cancelled = true;
-        this._animation = null;
-    }
-    if (typeof value === 'function' ||
-        (value !== null &&
-            typeof value === 'object' &&
-            value.onFrame !== undefined)) {
-        const animation = typeof value === 'function'
-            ? value()
-            : value;
-        // prevent setting again to the same value
-        // and triggering the mappers that treat this value as an input
-        // this happens when the animation's target value(stored in animation.current until animation.onStart is called) is set to the same value as a current one(this._value)
-        // built in animations that are not higher order(withTiming, withSpring) hold target value in .current
-        if (this._value === animation.current && !animation.isHigherOrder) {
-            animation.callback && animation.callback(true);
-            return;
-        }
-        // animated set
-        const initializeAnimation = (timestamp) => {
-            animation.onStart(animation, this.value, timestamp, previousAnimation);
-        };
-        initializeAnimation(getTimestamp());
-        const step = (timestamp) => {
-            if (animation.cancelled) {
-                animation.callback && animation.callback(false /* finished */);
-                return;
-            }
-            const finished = animation.onFrame(animation, timestamp);
-            animation.finished = true;
-            animation.timestamp = timestamp;
-            this._value = animation.current;
-            if (finished) {
-                animation.callback && animation.callback(true /* finished */);
-            }
-            else {
-                requestAnimationFrame(step);
-            }
-        };
-        this._animation = animation;
-        if (_frameTimestamp) {
-            // frame
-            step(_frameTimestamp);
-        }
-        else {
-            requestAnimationFrame(step);
-        }
-    }
-    else {
-        // prevent setting again to the same value
-        // and triggering the mappers that treat this value as an input
-        if (this._value === value) {
-            return;
-        }
-        this._value = value;
-    }
-}
-// We cannot use pushFrame
-// so we use own implementation for js
-function workletValueSetterJS(value) {
-    const previousAnimation = this._animation;
-    if (previousAnimation) {
-        previousAnimation.cancelled = true;
-        this._animation = null;
-    }
-    if (typeof value === 'function' ||
-        (value !== null &&
-            typeof value === 'object' &&
-            value.onFrame)) {
-        // animated set
-        const animation = typeof value === 'function'
-            ? value()
-            : value;
-        let initializeAnimation = (timestamp) => {
-            animation.onStart(animation, this.value, timestamp, previousAnimation);
-        };
-        const step = (timestamp) => {
-            if (animation.cancelled) {
-                animation.callback && animation.callback(false /* finished */);
-                return;
-            }
-            if (initializeAnimation) {
-                initializeAnimation(timestamp);
-                initializeAnimation = null; // prevent closure from keeping ref to previous animation
-            }
-            const finished = animation.onFrame(animation, timestamp);
-            animation.timestamp = timestamp;
-            this._setValue && this._setValue(animation.current);
-            if (finished) {
-                animation.callback && animation.callback(true /* finished */);
-            }
-            else {
-                requestFrame(step);
-            }
-        };
-        this._animation = animation;
-        requestFrame(step);
-    }
-    else {
-        this._setValue && this._setValue(value);
-    }
-}
-export function makeMutable(value) {
-    isConfiguredCheck();
-    return NativeReanimatedModule.makeMutable(value);
-}
-export function makeRemote(object = {}) {
-    isConfiguredCheck();
-    return NativeReanimatedModule.makeRemote(object);
-}
-export function startMapper(mapper, inputs = [], outputs = [], updater = () => {
-    // noop
-}, viewDescriptors = []) {
-    isConfiguredCheck();
-    return NativeReanimatedModule.startMapper(mapper, inputs, outputs, updater, viewDescriptors);
-}
-export function stopMapper(mapperId) {
-    NativeReanimatedModule.stopMapper(mapperId);
-}
-export function runOnJS(fun) {
-    'worklet';
-    if (!_WORKLET) {
-        return fun;
-    }
-    if (!fun.__callAsync) {
-        throw new Error("Attempting to call runOnJS with an object that is not a host function. Using runOnJS is only possible with methods that are defined on the main React-Native Javascript thread and that aren't marked as worklets");
-    }
-    else {
-        return fun.__callAsync;
-    }
-}
-NativeReanimatedModule.installCoreFunctions(NativeReanimatedModule.native
-    ? workletValueSetter
-    : workletValueSetterJS);
-if (!isWeb() && isConfigured()) {
-    const capturableConsole = console;
-    runOnUI(() => {
-        'worklet';
-        const console = {
-            debug: runOnJS(capturableConsole.debug),
-            log: runOnJS(capturableConsole.log),
-            warn: runOnJS(capturableConsole.warn),
-            error: runOnJS(capturableConsole.error),
-            info: runOnJS(capturableConsole.info),
-        };
-        _setGlobalConsole(console);
-    })();
-}
-let featuresConfig = {
-    enableLayoutAnimations: false,
-    setByUser: false,
-};
-export function enableLayoutAnimations(flag, isCallByUser = true) {
-    if (isCallByUser) {
-        featuresConfig = {
-            enableLayoutAnimations: flag,
-            setByUser: true,
-        };
-        NativeReanimatedModule.enableLayoutAnimations(flag);
-    }
-    else if (!featuresConfig.setByUser &&
-        featuresConfig.enableLayoutAnimations !== flag) {
-        featuresConfig.enableLayoutAnimations = flag;
-        NativeReanimatedModule.enableLayoutAnimations(flag);
-    }
-}
-export function configureProps(uiProps, nativeProps) {
-    if (!nativeShouldBeMock()) {
-        NativeReanimatedModule.configureProps(uiProps, nativeProps);
-    }
-}
-export function jestResetJsReanimatedModule() {
-    NativeReanimatedModule.jestResetModule();
-}

package/lib/reanimated2/globals.d.ts

@@ -1,60 +0,0 @@
-import { AnimatedStyle, StyleProps } from './commonTypes';
-import { ReanimatedConsole } from './core';
-import { MeasuredDimensions } from './NativeMethods';
-import { NativeReanimated } from './NativeReanimated/NativeReanimated';
-declare global {
-  const _WORKLET: boolean;
-  const _frameTimestamp: number;
-  const _eventTimestamp: number;
-  const _setGlobalConsole: (console?: ReanimatedConsole) => void;
-  const _getCurrentTime: () => number;
-  const _stopObservingProgress: (tag: number, flag: boolean) => void;
-  const _startObservingProgress: (
-    tag: number,
-    flag: { value: boolean; _value: boolean }
-  ) => void;
-  const _setGestureState: (handlerTag: number, newState: number) => void;
-  const _updateProps: (
-    tag: number,
-    name: string,
-    updates: StyleProps | AnimatedStyle
-  ) => void;
-  const _measure: (viewTag: number) => MeasuredDimensions;
-  const _scrollTo: (
-    viewTag: number,
-    x: number,
-    y: number,
-    animated: boolean
-  ) => void;
-  const _chronoNow: () => number;
-  const ReanimatedDataMock: {
-    now: () => number;
-  };
-  namespace NodeJS {
-    interface Global {
-      _setGlobalConsole: (console?: ReanimatedConsole) => void;
-      _log: (s: string) => void;
-      _setGestureState: () => void;
-      _WORKLET: boolean;
-      __reanimatedModuleProxy: NativeReanimated;
-      _frameTimestamp: number | null;
-      _measure: () => MeasuredDimensions;
-      _scrollTo: () => void;
-      _chronoNow: () => number;
-      performance: { now: () => number };
-      LayoutAnimationRepository: {
-        configs: Record<string, unknown>;
-        registerConfig(tag: number, config: Record<string, unknown>): void;
-        removeConfig(tag: number): void;
-        startAnimationForTag(
-          tag: number,
-          type: string,
-          yogaValues: unknown
-        ): void;
-      };
-      ReanimatedDataMock: {
-        now: () => number;
-      };
-    }
-  }
-}

package/lib/reanimated2/hook/Hooks.js

@@ -1,9 +0,0 @@
-import { useCallback } from 'react';
-import { useAnimatedStyle } from './useAnimatedStyle';
-// TODO: we should make sure that when useAP is used we are not assigning styles
-// when you need styles to animated you should always use useAS
-export const useAnimatedProps = useAnimatedStyle;
-export function useWorkletCallback(fun, deps) {
-    return useCallback(fun, deps !== null && deps !== void 0 ? deps : []);
-}
-export { useEvent, useHandler } from './utils';

package/lib/reanimated2/hook/commonTypes.js

@@ -1 +0,0 @@
-export {};

package/lib/reanimated2/hook/index.js

@@ -1,9 +0,0 @@
-export { useAnimatedProps, useEvent, useHandler, useWorkletCallback, } from './Hooks';
-export { useSharedValue } from './useSharedValue';
-export { useAnimatedStyle } from './useAnimatedStyle';
-export { useAnimatedGestureHandler, } from './useAnimatedGestureHandler';
-export { useAnimatedReaction, } from './useAnimatedReaction';
-export { useAnimatedRef } from './useAnimatedRef';
-export { useAnimatedScrollHandler, } from './useAnimatedScrollHandler';
-export { useDerivedValue } from './useDerivedValue';
-export { useAnimatedSensor, SensorType } from './useAnimatedSensor';

package/lib/reanimated2/hook/useAnimatedGestureHandler.js

@@ -1,49 +0,0 @@
-import { useEvent, useHandler } from './Hooks';
-export var EventType;
-(function (EventType) {
-    EventType[EventType["UNDETERMINED"] = 0] = "UNDETERMINED";
-    EventType[EventType["FAILED"] = 1] = "FAILED";
-    EventType[EventType["BEGAN"] = 2] = "BEGAN";
-    EventType[EventType["CANCELLED"] = 3] = "CANCELLED";
-    EventType[EventType["ACTIVE"] = 4] = "ACTIVE";
-    EventType[EventType["END"] = 5] = "END";
-})(EventType || (EventType = {}));
-export function useAnimatedGestureHandler(handlers, dependencies) {
-    const { context, doDependenciesDiffer, useWeb } = useHandler(handlers, dependencies);
-    const handler = (e) => {
-        'worklet';
-        const event = useWeb ? e.nativeEvent : e;
-        if (event.state === EventType.BEGAN && handlers.onStart) {
-            handlers.onStart(event, context);
-        }
-        if (event.state === EventType.ACTIVE && handlers.onActive) {
-            handlers.onActive(event, context);
-        }
-        if (event.oldState === EventType.ACTIVE &&
-            event.state === EventType.END &&
-            handlers.onEnd) {
-            handlers.onEnd(event, context);
-        }
-        if (event.oldState === EventType.BEGAN &&
-            event.state === EventType.FAILED &&
-            handlers.onFail) {
-            handlers.onFail(event, context);
-        }
-        if (event.oldState === EventType.ACTIVE &&
-            event.state === EventType.CANCELLED &&
-            handlers.onCancel) {
-            handlers.onCancel(event, context);
-        }
-        if ((event.oldState === EventType.BEGAN ||
-            event.oldState === EventType.ACTIVE) &&
-            event.state !== EventType.BEGAN &&
-            event.state !== EventType.ACTIVE &&
-            handlers.onFinish) {
-            handlers.onFinish(event, context, event.state === EventType.CANCELLED || event.state === EventType.FAILED);
-        }
-    };
-    if (useWeb) {
-        return handler;
-    }
-    return useEvent(handler, ['onGestureHandlerStateChange', 'onGestureHandlerEvent'], doDependenciesDiffer);
-}

package/lib/reanimated2/hook/useAnimatedReaction.js

@@ -1,37 +0,0 @@
-import { useEffect } from 'react';
-import { startMapper, stopMapper } from '../core';
-import { useSharedValue } from './useSharedValue';
-/**
- * @param prepare - worklet used for data preparation for the second parameter
- * @param react - worklet which takes data prepared by the one in the first parameter and performs certain actions
- * the first worklet defines the inputs, in other words on which shared values change will it be called.
- * the second one can modify any shared values but those which are mentioned in the first worklet. Beware of that, because this may result in endless loop and high cpu usage.
- */
-export function useAnimatedReaction(prepare, react, dependencies) {
-    var _a, _b;
-    const previous = useSharedValue(null);
-    if (dependencies === undefined) {
-        dependencies = [
-            Object.values((_a = prepare._closure) !== null && _a !== void 0 ? _a : {}),
-            Object.values((_b = react._closure) !== null && _b !== void 0 ? _b : {}),
-            prepare.__workletHash,
-            react.__workletHash,
-        ];
-    }
-    else {
-        dependencies.push(prepare.__workletHash, react.__workletHash);
-    }
-    useEffect(() => {
-        var _a;
-        const fun = () => {
-            'worklet';
-            const input = prepare();
-            react(input, previous.value);
-            previous.value = input;
-        };
-        const mapperId = startMapper(fun, Object.values((_a = prepare._closure) !== null && _a !== void 0 ? _a : {}), []);
-        return () => {
-            stopMapper(mapperId);
-        };
-    }, dependencies);
-}