react-native-reanimated 2.3.0-alpha.1 → 2.3.0-beta.2

package/lib/reanimated2/hook/utils.js

@@ -0,0 +1,175 @@
+import { useEffect, useRef } from 'react';
+import { processColor } from '../Colors';
+import { makeRemote } from '../core';
+import { isWeb } from '../PlatformChecker';
+import { colorProps } from '../UpdateProps';
+import WorkletEventHandler from '../WorkletEventHandler';
+export function useEvent(handler, eventNames = [], rebuild = false) {
+    const initRef = useRef(null);
+    if (initRef.current === null) {
+        initRef.current = new WorkletEventHandler(handler, eventNames);
+    }
+    else if (rebuild) {
+        initRef.current.updateWorklet(handler);
+    }
+    useEffect(() => {
+        return () => {
+            initRef.current = null;
+        };
+    }, []);
+    return initRef;
+}
+export function useHandler(handlers, dependencies) {
+    const initRef = useRef(null);
+    if (initRef.current === null) {
+        initRef.current = {
+            context: makeRemote({}),
+            savedDependencies: [],
+        };
+    }
+    useEffect(() => {
+        return () => {
+            initRef.current = null;
+        };
+    }, []);
+    const { context, savedDependencies } = initRef.current;
+    dependencies = buildDependencies(dependencies, handlers);
+    const doDependenciesDiffer = !areDependenciesEqual(dependencies, savedDependencies);
+    initRef.current.savedDependencies = dependencies;
+    const useWeb = isWeb();
+    return { context, doDependenciesDiffer, useWeb };
+}
+// builds one big hash from multiple worklets' hashes
+export function buildWorkletsHash(handlers) {
+    return Object.values(handlers).reduce((acc, worklet) => 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    acc + worklet.__workletHash.toString(), '');
+}
+// builds dependencies array for gesture handlers
+export function buildDependencies(dependencies, handlers) {
+    const handlersList = Object.values(handlers).filter((handler) => handler !== undefined);
+    if (!dependencies) {
+        dependencies = handlersList.map((handler) => {
+            return {
+                workletHash: handler.__workletHash,
+                closure: handler._closure,
+            };
+        });
+    }
+    else {
+        dependencies.push(buildWorkletsHash(handlersList));
+    }
+    return dependencies;
+}
+// this is supposed to work as useEffect comparison
+export function areDependenciesEqual(nextDeps, prevDeps) {
+    function is(x, y) {
+        /* eslint-disable no-self-compare */
+        return (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y);
+        /* eslint-enable no-self-compare */
+    }
+    const objectIs = typeof Object.is === 'function' ? Object.is : is;
+    function areHookInputsEqual(nextDeps, prevDeps) {
+        if (!nextDeps || !prevDeps || prevDeps.length !== nextDeps.length) {
+            return false;
+        }
+        for (let i = 0; i < prevDeps.length; ++i) {
+            if (!objectIs(nextDeps[i], prevDeps[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return areHookInputsEqual(nextDeps, prevDeps);
+}
+export function hasColorProps(updates) {
+    const colorPropsSet = new Set(colorProps);
+    for (const key in updates) {
+        if (colorPropsSet.has(key)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function parseColors(updates) {
+    'worklet';
+    for (const key in updates) {
+        if (colorProps.indexOf(key) !== -1) {
+            updates[key] = processColor(updates[key]);
+        }
+    }
+}
+export function canApplyOptimalisation(upadterFn) {
+    const FUNCTIONLESS_FLAG = 0b00000001;
+    const STATEMENTLESS_FLAG = 0b00000010;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const optimalization = upadterFn.__optimalization;
+    return (optimalization & FUNCTIONLESS_FLAG && optimalization & STATEMENTLESS_FLAG);
+}
+export function isAnimated(prop) {
+    'worklet';
+    const propsToCheck = [prop];
+    while (propsToCheck.length > 0) {
+        const currentProp = propsToCheck.pop();
+        if (Array.isArray(currentProp)) {
+            for (const item of currentProp) {
+                propsToCheck.push(item);
+            }
+        }
+        else if ((currentProp === null || currentProp === void 0 ? void 0 : currentProp.onFrame) !== undefined) {
+            return true;
+        }
+        else if (typeof currentProp === 'object') {
+            for (const item of Object.values(currentProp)) {
+                propsToCheck.push(item);
+            }
+        }
+        // if none of the above, it's not the animated prop, check next one
+    }
+    // when none of the props were animated return false
+    return false;
+}
+export function styleDiff(oldStyle, newStyle) {
+    'worklet';
+    const diff = {};
+    Object.keys(oldStyle).forEach((key) => {
+        if (newStyle[key] === undefined) {
+            diff[key] = null;
+        }
+    });
+    Object.keys(newStyle).forEach((key) => {
+        const value = newStyle[key];
+        const oldValue = oldStyle[key];
+        if (isAnimated(value)) {
+            // do nothing
+            return;
+        }
+        if (oldValue !== value &&
+            JSON.stringify(oldValue) !== JSON.stringify(value)) {
+            // I'd use deep equal here but that'd take additional work and this was easier
+            diff[key] = value;
+        }
+    });
+    return diff;
+}
+export function getStyleWithoutAnimations(newStyle) {
+    'worklet';
+    const diff = {};
+    for (const key in newStyle) {
+        const value = newStyle[key];
+        if (isAnimated(value)) {
+            continue;
+        }
+        diff[key] = value;
+    }
+    return diff;
+}
+export const validateAnimatedStyles = (styles) => {
+    'worklet';
+    if (typeof styles !== 'object') {
+        throw new Error(`useAnimatedStyle has to return an object, found ${typeof styles} instead`);
+    }
+    else if (Array.isArray(styles)) {
+        throw new Error('useAnimatedStyle has to return an object and cannot return static styles combined with dynamic ones. Please do merging where a component receives props.');
+    }
+};

package/lib/reanimated2/index.js

@@ -1,9 +1,10 @@
 export * from './core';
-export * from './Hooks';
-export * from './animations';
+export * from './hook';
+export * from './animation';
 export * from './interpolation';
 export * from './Easing';
 export * from './NativeMethods';
 export * from './Colors';
 export * from './PropAdapters';
 export * from './layoutReanimation';
+export * from './utils';

package/lib/reanimated2/interpolation.js

@@ -1,118 +1,127 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-import interpolateNode, { Extrapolate, } from '../reanimated1/derived/interpolate';
-function getVal(config) {
+// @ts-ignore JS file
+import interpolateNode from '../reanimated1/derived/interpolate';
+export var Extrapolation;
+(function (Extrapolation) {
+    Extrapolation["IDENTITY"] = "identity";
+    Extrapolation["CLAMP"] = "clamp";
+    Extrapolation["EXTEND"] = "extend";
+})(Extrapolation || (Extrapolation = {}));
+function isNode(x) {
+    'worklet';
+    return x.__nodeId !== undefined;
+}
+function getVal(type, coef, val, leftEdgeOutput, rightEdgeOutput, x) {
     'worklet';
-    const { type, coef, val, ll, rr, x } = config;
     switch (type) {
-        case Extrapolate.IDENTITY:
+        case Extrapolation.IDENTITY:
             return x;
-        case Extrapolate.CLAMP:
-            if (coef * val < coef * ll) {
-                return ll;
+        case Extrapolation.CLAMP:
+            if (coef * val < coef * leftEdgeOutput) {
+                return leftEdgeOutput;
             }
-            return rr;
-        case Extrapolate.EXTEND:
+            return rightEdgeOutput;
+        case Extrapolation.EXTEND:
         default:
             return val;
     }
 }
 function isExtrapolate(value) {
     'worklet';
-    return (value === Extrapolate.EXTEND ||
-        value === Extrapolate.CLAMP ||
-        value === Extrapolate.IDENTITY);
+    return (value === Extrapolation.EXTEND ||
+        value === Extrapolation.CLAMP ||
+        value === Extrapolation.IDENTITY);
 }
+// validates extrapolations type
+// if type is correct, converts it to ExtrapolationConfig
 function validateType(type) {
     'worklet';
-    const EXTRAPOLATE_ERROR_MSG = `Reanimated: config object is not valid, please provide valid config, for example:
-    interpolate(value, [inputRange], [outputRange], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'extend',
-  })`;
-    const EXTRAPOLATE_ERROR = (extrapolate) => `Reanimated: not supported value for "${extrapolate}" \nSupported values: ["extend", "clamp", "identity"]\n Valid example:
-    interpolate(value, [inputRange], [outputRange], {
-      ${extrapolate}: 'clamp',
-  })`;
-    type = type !== null && type !== void 0 ? type : 'extend';
-    // eslint-disable-next-line no-prototype-builtins
-    const hasExtrapolateLeft = type.hasOwnProperty('extrapolateLeft');
-    // eslint-disable-next-line no-prototype-builtins
-    const hasExtrapolateRight = type.hasOwnProperty('extrapolateRight');
-    if (typeof type === 'object' &&
-        ((Object.keys(type).length === 2 &&
-            !(hasExtrapolateLeft && hasExtrapolateRight)) ||
-            (Object.keys(type).length === 1 &&
-                !(hasExtrapolateLeft || hasExtrapolateRight)) ||
-            Object.keys(type).length > 2)) {
-        throw new Error(EXTRAPOLATE_ERROR_MSG);
+    // initialize extrapolationConfig with default extrapolation
+    const extrapolationConfig = {
+        extrapolateLeft: Extrapolation.EXTEND,
+        extrapolateRight: Extrapolation.EXTEND,
+    };
+    if (!type) {
+        return extrapolationConfig;
     }
-    if (typeof type === 'object') {
-        if (hasExtrapolateLeft && !isExtrapolate(type.extrapolateLeft)) {
-            throw new Error(EXTRAPOLATE_ERROR('extrapolateLeft'));
-        }
-        if (hasExtrapolateRight && !isExtrapolate(type.extrapolateRight)) {
-            throw new Error(EXTRAPOLATE_ERROR('extrapolateRight'));
+    if (typeof type === 'string') {
+        if (!isExtrapolate(type)) {
+            throw new Error(`Reanimated: not supported value for "interpolate" \nSupported values: ["extend", "clamp", "identity", Extrapolatation.CLAMP, Extrapolatation.EXTEND, Extrapolatation.IDENTITY]\n Valid example:
+        interpolate(value, [inputRange], [outputRange], "clamp")`);
         }
+        extrapolationConfig.extrapolateLeft = type;
+        extrapolationConfig.extrapolateRight = type;
+        return extrapolationConfig;
     }
-    if (typeof type === 'string' && !isExtrapolate(type)) {
-        throw new Error(`Reanimated: not supported value for "interpolate" \nSupported values: ["extend", "clamp", "identity"]\n Valid example:
-       interpolate(value, [inputRange], [outputRange], "clamp")`);
+    // otherwise type is extrapolation config object
+    if ((type.extrapolateLeft && !isExtrapolate(type.extrapolateLeft)) ||
+        (type.extrapolateRight && !isExtrapolate(type.extrapolateRight))) {
+        throw new Error(`Reanimated: not supported value for "interpolate" \nSupported values: ["extend", "clamp", "identity", Extrapolatation.CLAMP, Extrapolatation.EXTEND, Extrapolatation.IDENTITY]\n Valid example:
+      interpolate(value, [inputRange], [outputRange], {
+        extrapolateLeft: Extrapolation.CLAMP,
+        extrapolateRight: Extrapolation.IDENTITY
+      }})`);
     }
+    Object.assign(extrapolationConfig, type);
+    return extrapolationConfig;
 }
-// TODO: support default values in worklets:
-// e.g. function interpolate(x, input, output, type = Extrapolate.CLAMP)
-function internalInterpolate(x, l, r, ll, rr, type) {
+function internalInterpolate(x, narrowedInput, extrapolationConfig) {
     'worklet';
-    if (r - l === 0)
-        return ll;
-    const progress = (x - l) / (r - l);
-    const val = ll + progress * (rr - ll);
-    const coef = rr >= ll ? 1 : -1;
-    const config = { type, coef, val, ll, rr, x };
-    if (__DEV__)
-        validateType(type);
-    if (typeof type === 'object') {
-        if (coef * val < coef * ll) {
-            return getVal(Object.assign(config, { type: type.extrapolateLeft }));
-        }
-        else if (coef * val > coef * ll) {
-            return getVal(Object.assign(config, { type: type.extrapolateRight }));
-        }
+    const { leftEdgeInput, rightEdgeInput, leftEdgeOutput, rightEdgeOutput, } = narrowedInput;
+    if (rightEdgeInput - leftEdgeInput === 0)
+        return leftEdgeOutput;
+    const progress = (x - leftEdgeInput) / (rightEdgeInput - leftEdgeInput);
+    const val = leftEdgeOutput + progress * (rightEdgeOutput - leftEdgeOutput);
+    const coef = rightEdgeOutput >= leftEdgeOutput ? 1 : -1;
+    if (coef * val < coef * leftEdgeOutput) {
+        return getVal(extrapolationConfig.extrapolateLeft, coef, val, leftEdgeOutput, rightEdgeOutput, x);
     }
-    if (coef * val < coef * ll || coef * val > coef * rr) {
-        return getVal(config);
+    else if (coef * val > coef * rightEdgeOutput) {
+        return getVal(extrapolationConfig.extrapolateRight, coef, val, leftEdgeOutput, rightEdgeOutput, x);
     }
     return val;
 }
+// TODO: support default values in worklets:
+// e.g. function interpolate(x, input, output, type = Extrapolatation.CLAMP)
 export function interpolate(x, input, output, type) {
     'worklet';
-    if (x && x.__nodeID) {
+    if (input.length < 2 || output.length < 2) {
+        throw Error('Interpolation input and output should contain at least two values.');
+    }
+    const extrapolationConfig = validateType(type);
+    if (isNode(x)) {
         console.warn(`interpolate() was renamed to interpolateNode() in Reanimated 2. Please use interpolateNode() instead`);
-        // we can't use rest parameters in worklets at the moment
-        // eslint-disable-next-line prefer-spread, prefer-rest-params
-        return interpolateNode.apply(undefined, arguments);
+        return interpolateNode(x, {
+            inputRange: input,
+            outputRange: output,
+            extrapolateLeft: extrapolationConfig.extrapolateLeft,
+            extrapolateRight: extrapolationConfig.extrapolateRight,
+        });
     }
     const length = input.length;
-    let narrowedInput = [];
-    if (x < input[0]) {
-        narrowedInput = [input[0], input[1], output[0], output[1]];
-    }
-    else if (x > input[length - 1]) {
-        narrowedInput = [
-            input[length - 2],
-            input[length - 1],
-            output[length - 2],
-            output[length - 1],
-        ];
-    }
-    else {
-        for (let i = 1; i < length; ++i) {
-            if (x <= input[i]) {
-                narrowedInput = [input[i - 1], input[i], output[i - 1], output[i]];
-                break;
+    const narrowedInput = {
+        leftEdgeInput: input[0],
+        rightEdgeInput: input[1],
+        leftEdgeOutput: output[0],
+        rightEdgeOutput: output[1],
+    };
+    if (length > 2) {
+        if (x > input[length - 1]) {
+            narrowedInput.leftEdgeInput = input[length - 2];
+            narrowedInput.rightEdgeInput = input[length - 1];
+            narrowedInput.leftEdgeOutput = output[length - 2];
+            narrowedInput.rightEdgeOutput = output[length - 1];
+        }
+        else {
+            for (let i = 1; i < length; ++i) {
+                if (x <= input[i]) {
+                    narrowedInput.leftEdgeInput = input[i - 1];
+                    narrowedInput.rightEdgeInput = input[i];
+                    narrowedInput.leftEdgeOutput = output[i - 1];
+                    narrowedInput.rightEdgeOutput = output[i];
+                    break;
+                }
             }
         }
     }
-    return internalInterpolate.apply({}, [x].concat(narrowedInput).concat(type));
+    return internalInterpolate(x, narrowedInput, extrapolationConfig);
 }

package/lib/reanimated2/jestUtils.js

@@ -149,18 +149,6 @@ export const setUpTests = (userConfig = {}) => {
             return compareStyle(received, expectedStyle, config);
         },
     });
-    jest.mock('./js-reanimated', () => require('./js-reanimated/index.web'));
-    jest.mock('../ReanimatedModule', () => require('../ReanimatedModuleCompat'));
-    jest.mock('./NativeReanimated', () => {
-        let module;
-        try {
-            module = require('./NativeReanimated.js');
-        }
-        catch (_a) {
-            module = require('./NativeReanimated.ts');
-        }
-        return module.default;
-    });
 };
 export const getAnimatedStyle = (received) => {
     return getCurrentStyle(received);

package/lib/reanimated2/js-reanimated/JSReanimated.js

@@ -1,21 +1,19 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
 import MapperRegistry from './MapperRegistry';
 import MutableValue from './MutableValue';
 import Mapper from './Mapper';
-export default class JSReanimated {
+import { NativeReanimated } from '../NativeReanimated/NativeReanimated';
+export default class JSReanimated extends NativeReanimated {
     constructor() {
-        this.native = false;
+        super(false);
         this._valueSetter = undefined;
         this._renderRequested = false;
         this._mapperRegistry = new MapperRegistry(this);
         this._frames = [];
-        this.timeProvider = {};
         if (process.env.JEST_WORKER_ID) {
-            this.timeProvider.now = () => Date.now();
+            this.timeProvider = { now: () => Date.now() };
         }
         else {
-            this.timeProvider.now = () => window.performance.now();
+            this.timeProvider = { now: () => window.performance.now() };
         }
     }
     pushFrame(frame) {
@@ -54,7 +52,7 @@ export default class JSReanimated {
     makeMutable(value) {
         return new MutableValue(value, this._valueSetter);
     }
-    makeRemote(object) {
+    makeRemote(object = {}) {
         return object;
     }
     startMapper(mapper, inputs = [], outputs = []) {
@@ -66,10 +64,11 @@ export default class JSReanimated {
     stopMapper(mapperId) {
         this._mapperRegistry.stopMapper(mapperId);
     }
-    registerEventHandler(_eventHash, _eventHandler) {
+    registerEventHandler(_, __) {
         // noop
+        return '';
     }
-    unregisterEventHandler(_registrationId) {
+    unregisterEventHandler(_) {
         // noop
     }
 }

package/lib/reanimated2/js-reanimated/index.js

@@ -1 +1,57 @@
-"use strict";
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+import JSReanimated from './JSReanimated';
+import { shouldBeUseWeb } from '../PlatformChecker';
+const reanimatedJS = new JSReanimated();
+if (shouldBeUseWeb()) {
+    global._frameTimestamp = null;
+    global._setGlobalConsole = (_val) => {
+        // noop
+    };
+    global._measure = () => {
+        console.warn("[Reanimated] You can't use 'measue' method with Chrome Debugger or with web version");
+        return {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            pageX: 0,
+            pageY: 0,
+        };
+    };
+    global._scrollTo = () => {
+        console.warn("[Reanimated] You can't use 'scrollTo' method with Chrome Debugger or with web version");
+    };
+}
+export const _updatePropsJS = (updates, viewRef) => {
+    if (viewRef === null || viewRef === void 0 ? void 0 : viewRef._component) {
+        const [rawStyles] = Object.keys(updates).reduce((acc, key) => {
+            const value = updates[key];
+            const index = typeof value === 'function' ? 1 : 0;
+            acc[index][key] = value;
+            return acc;
+        }, [{}, {}]);
+        if (typeof viewRef._component.setNativeProps === 'function') {
+            setNativeProps(viewRef._component, rawStyles);
+        }
+        else if (Object.keys(viewRef._component.props).length > 0) {
+            Object.keys(viewRef._component.props).forEach((key) => {
+                if (!rawStyles[key]) {
+                    return;
+                }
+                const dashedKey = key.replace(/[A-Z]/g, (m) => '-' + m.toLowerCase());
+                viewRef._component._touchableNode.setAttribute(dashedKey, rawStyles[key]);
+            });
+        }
+        else {
+            console.warn('It is not possible to manipulate component');
+        }
+    }
+};
+const setNativeProps = (component, style) => {
+    const previousStyle = component.previousStyle ? component.previousStyle : {};
+    const currentStyle = Object.assign(Object.assign({}, previousStyle), style);
+    component.previousStyle = currentStyle;
+    component.setNativeProps({ style: currentStyle });
+};
+export default reanimatedJS;

package/lib/reanimated2/layoutReanimation/LayoutAnimationRepository.js

@@ -0,0 +1,58 @@
+/* global _stopObservingProgress, _startObservingProgress */
+import { runOnUI } from '../core';
+import { withStyleAnimation } from '../animation/styleAnimation';
+runOnUI(() => {
+    'worklet';
+    const configs = {};
+    const enteringAnimationForTag = {};
+    global.LayoutAnimationRepository = {
+        configs,
+        registerConfig(tag, config) {
+            configs[tag] = config;
+            enteringAnimationForTag[tag] = null;
+        },
+        removeConfig(tag) {
+            delete configs[tag];
+            delete enteringAnimationForTag[tag];
+        },
+        startAnimationForTag(tag, type, yogaValues) {
+            if (configs[tag] == null) {
+                return; // :(
+            }
+            const style = configs[tag][type](yogaValues);
+            let currentAnimation = style.animations;
+            if (type === 'entering') {
+                enteringAnimationForTag[tag] = style;
+            }
+            else if (type === 'layout' && enteringAnimationForTag[tag] !== null) {
+                const entryAniamtion = enteringAnimationForTag[tag].animations;
+                const layoutAnimation = style.animations;
+                currentAnimation = {};
+                for (const key in entryAniamtion) {
+                    currentAnimation[key] = entryAniamtion[key];
+                }
+                for (const key in layoutAnimation) {
+                    currentAnimation[key] = layoutAnimation[key];
+                }
+                enteringAnimationForTag[tag] = null;
+            }
+            const sv = configs[tag].sv;
+            _stopObservingProgress(tag, false);
+            _startObservingProgress(tag, sv);
+            sv._value = Object.assign({}, sv._value, style.initialValues);
+            _stopObservingProgress(tag, false);
+            const animation = withStyleAnimation(currentAnimation);
+            animation.callback = (finished) => {
+                if (finished) {
+                    _stopObservingProgress(tag, finished);
+                }
+                style.callback && style.callback(finished);
+                if (type === 'entering') {
+                    enteringAnimationForTag[tag] = null;
+                }
+            };
+            configs[tag].sv.value = animation;
+            _startObservingProgress(tag, sv);
+        },
+    };
+})();

package/lib/reanimated2/layoutReanimation/animationBuilder/BaseAnimationBuilder.js

@@ -0,0 +1,69 @@
+import { withDelay } from '../../animation';
+export class BaseAnimationBuilder {
+    constructor() {
+        this.randomizeDelay = false;
+        this.build = () => {
+            throw Error('Unimplemented method in child class.');
+        };
+    }
+    static duration(durationMs) {
+        const instance = this.createInstance();
+        return instance.duration(durationMs);
+    }
+    duration(durationMs) {
+        this.durationV = durationMs;
+        return this;
+    }
+    static delay(delayMs) {
+        const instance = this.createInstance();
+        return instance.delay(delayMs);
+    }
+    delay(delayMs) {
+        this.delayV = delayMs;
+        return this;
+    }
+    static withCallback(callback) {
+        const instance = this.createInstance();
+        return instance.withCallback(callback);
+    }
+    withCallback(callback) {
+        this.callbackV = callback;
+        return this;
+    }
+    // 300ms is the default animation duration. If any animation has different default has to override this method.
+    static getDuration() {
+        return 300;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 300;
+    }
+    static randomDelay() {
+        const instance = this.createInstance();
+        return instance.randomDelay();
+    }
+    randomDelay() {
+        this.randomizeDelay = true;
+        return this;
+    }
+    // when randomizeDelay is set to true, randomize delay between 0 and provided value (or 1000ms if delay is not provided)
+    getDelay() {
+        var _a, _b;
+        return this.randomizeDelay
+            ? Math.random() * ((_a = this.delayV) !== null && _a !== void 0 ? _a : 1000)
+            : (_b = this.delayV) !== null && _b !== void 0 ? _b : 0;
+    }
+    getDelayFunction() {
+        const isDelayProvided = this.randomizeDelay || this.delayV;
+        return isDelayProvided
+            ? withDelay
+            : (_, animation) => {
+                'worklet';
+                return animation;
+            };
+    }
+    static build() {
+        const instance = this.createInstance();
+        return instance.build();
+    }
+}