react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/lib/reanimated2/hook/utils.js

@@ -1,173 +0,0 @@
-import { useEffect, useRef } from 'react';
-import { processColor } from '../Colors';
-import { makeRemote } from '../core';
-import { isWeb, isJest } 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);
-    }
-    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() || isJest();
-    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) {
-            // value could be an animation in which case processColor will recognize it and will return undefined
-            // -> in such a case we don't want to override style of that key
-            const processedColor = processColor(updates[key]);
-            if (processedColor !== undefined) {
-                updates[key] = processedColor;
-            }
-        }
-    }
-}
-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 = {};
-    for (const key in oldStyle) {
-        if (newStyle[key] === undefined) {
-            diff[key] = null;
-        }
-    }
-    for (const key in newStyle) {
-        const value = newStyle[key];
-        const oldValue = oldStyle[key];
-        if (isAnimated(value)) {
-            // do nothing
-            continue;
-        }
-        if (oldValue !== value) {
-            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,12 +0,0 @@
-export * from './core';
-export * from './hook';
-export * from './animation';
-export * from './interpolation';
-export * from './interpolateColor';
-export * from './Easing';
-export * from './NativeMethods';
-export * from './Colors';
-export * from './PropAdapters';
-export * from './layoutReanimation';
-export * from './utils';
-export * from './commonTypes';

package/lib/reanimated2/interpolateColor.js

@@ -1,98 +0,0 @@
-import { hsvToColor, RGBtoHSV, rgbaColor, processColor, red, green, blue, opacity, } from './Colors';
-import { makeMutable } from './core';
-import { interpolate } from './interpolation';
-// @ts-ignore JS file
-import { Extrapolate } from '../reanimated1/derived';
-import { useSharedValue } from './hook/useSharedValue';
-const interpolateColorsHSV = (value, inputRange, colors) => {
-    'worklet';
-    const h = interpolate(value, inputRange, colors.h, Extrapolate.CLAMP);
-    const s = interpolate(value, inputRange, colors.s, Extrapolate.CLAMP);
-    const v = interpolate(value, inputRange, colors.v, Extrapolate.CLAMP);
-    return hsvToColor(h, s, v);
-};
-const interpolateColorsRGB = (value, inputRange, colors) => {
-    'worklet';
-    const r = interpolate(value, inputRange, colors.r, Extrapolate.CLAMP);
-    const g = interpolate(value, inputRange, colors.g, Extrapolate.CLAMP);
-    const b = interpolate(value, inputRange, colors.b, Extrapolate.CLAMP);
-    const a = interpolate(value, inputRange, colors.a, Extrapolate.CLAMP);
-    return rgbaColor(r, g, b, a);
-};
-const getInterpolateRGB = (colors) => {
-    'worklet';
-    const r = [];
-    const g = [];
-    const b = [];
-    const a = [];
-    for (let i = 0; i < colors.length; ++i) {
-        const color = colors[i];
-        const processedColor = processColor(color);
-        // explicit check in case if processedColor is 0
-        if (processedColor !== null && processedColor !== undefined) {
-            r.push(red(processedColor));
-            g.push(green(processedColor));
-            b.push(blue(processedColor));
-            a.push(opacity(processedColor));
-        }
-    }
-    return { r, g, b, a };
-};
-const getInterpolateHSV = (colors) => {
-    'worklet';
-    const h = [];
-    const s = [];
-    const v = [];
-    for (let i = 0; i < colors.length; ++i) {
-        const color = colors[i];
-        const processedColor = RGBtoHSV(processColor(color));
-        if (processedColor) {
-            h.push(processedColor.h);
-            s.push(processedColor.s);
-            v.push(processedColor.v);
-        }
-    }
-    return { h, s, v };
-};
-export const interpolateColor = (value, inputRange, outputRange, colorSpace = 'RGB') => {
-    'worklet';
-    if (colorSpace === 'HSV') {
-        return interpolateColorsHSV(value, inputRange, getInterpolateHSV(outputRange));
-    }
-    else if (colorSpace === 'RGB') {
-        return interpolateColorsRGB(value, inputRange, getInterpolateRGB(outputRange));
-    }
-    throw new Error(`Invalid color space provided: ${colorSpace}. Supported values are: ['RGB', 'HSV']`);
-};
-export var ColorSpace;
-(function (ColorSpace) {
-    ColorSpace[ColorSpace["RGB"] = 0] = "RGB";
-    ColorSpace[ColorSpace["HSV"] = 1] = "HSV";
-})(ColorSpace || (ColorSpace = {}));
-export function useInterpolateConfig(inputRange, outputRange, colorSpace = ColorSpace.RGB) {
-    return useSharedValue({
-        inputRange,
-        outputRange,
-        colorSpace,
-        cache: makeMutable(null),
-    });
-}
-export const interpolateSharableColor = (value, interpolateConfig) => {
-    'worklet';
-    let colors = interpolateConfig.value.cache.value;
-    if (interpolateConfig.value.colorSpace === ColorSpace.RGB) {
-        if (!colors) {
-            colors = getInterpolateRGB(interpolateConfig.value.outputRange);
-            interpolateConfig.value.cache.value = colors;
-        }
-        return interpolateColorsRGB(value, interpolateConfig.value.inputRange, colors);
-    }
-    else if (interpolateConfig.value.colorSpace === ColorSpace.HSV) {
-        if (!colors) {
-            colors = getInterpolateHSV(interpolateConfig.value.outputRange);
-            interpolateConfig.value.cache.value = colors;
-        }
-        return interpolateColorsHSV(value, interpolateConfig.value.inputRange, colors);
-    }
-    throw new Error(`Invalid color space provided: ${interpolateConfig.value.colorSpace}. Supported values are: ['RGB', 'HSV']`);
-};

package/lib/reanimated2/interpolation.js

@@ -1,127 +0,0 @@
-// @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';
-    switch (type) {
-        case Extrapolation.IDENTITY:
-            return x;
-        case Extrapolation.CLAMP:
-            if (coef * val < coef * leftEdgeOutput) {
-                return leftEdgeOutput;
-            }
-            return rightEdgeOutput;
-        case Extrapolation.EXTEND:
-        default:
-            return val;
-    }
-}
-function isExtrapolate(value) {
-    'worklet';
-    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';
-    // initialize extrapolationConfig with default extrapolation
-    const extrapolationConfig = {
-        extrapolateLeft: Extrapolation.EXTEND,
-        extrapolateRight: Extrapolation.EXTEND,
-    };
-    if (!type) {
-        return extrapolationConfig;
-    }
-    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;
-    }
-    // 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;
-}
-function internalInterpolate(x, narrowedInput, extrapolationConfig) {
-    'worklet';
-    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);
-    }
-    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 (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`);
-        return interpolateNode(x, {
-            inputRange: input,
-            outputRange: output,
-            extrapolateLeft: extrapolationConfig.extrapolateLeft,
-            extrapolateRight: extrapolationConfig.extrapolateRight,
-        });
-    }
-    const length = input.length;
-    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(x, narrowedInput, extrapolationConfig);
-}

package/lib/reanimated2/jestUtils.js

@@ -1,160 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-import { jestResetJsReanimatedModule } from './core';
-let config = {
-    fps: 60,
-};
-const isAnimatedStyle = (style) => {
-    return !!style.animatedStyle;
-};
-const getAnimatedStyleFromObject = (style) => {
-    return style.animatedStyle.current.value;
-};
-const getCurrentStyle = (received) => {
-    const styleObject = received.props.style;
-    let currentStyle = {};
-    if (Array.isArray(styleObject)) {
-        received.props.style.forEach((style) => {
-            if (isAnimatedStyle(style)) {
-                currentStyle = Object.assign(Object.assign({}, currentStyle), getAnimatedStyleFromObject(style));
-            }
-            else {
-                currentStyle = Object.assign(Object.assign({}, currentStyle), style);
-            }
-        });
-    }
-    else {
-        if (isAnimatedStyle(styleObject)) {
-            currentStyle = getAnimatedStyleFromObject(styleObject);
-        }
-        else {
-            currentStyle = Object.assign(Object.assign({}, styleObject), received.props.animatedStyle.value);
-        }
-    }
-    return currentStyle;
-};
-const checkEqual = (currentStyle, expectStyle) => {
-    if (Array.isArray(expectStyle)) {
-        if (expectStyle.length !== currentStyle.length)
-            return false;
-        for (let i = 0; i < currentStyle.length; i++) {
-            if (!checkEqual(currentStyle[i], expectStyle[i])) {
-                return false;
-            }
-        }
-    }
-    else if (typeof currentStyle === 'object' && currentStyle) {
-        for (const property in expectStyle) {
-            if (!checkEqual(currentStyle[property], expectStyle[property])) {
-                return false;
-            }
-        }
-    }
-    else {
-        return currentStyle === expectStyle;
-    }
-    return true;
-};
-const findStyleDiff = (current, expect, requireAllMatch) => {
-    const diffs = [];
-    let isEqual = true;
-    for (const property in expect) {
-        if (!checkEqual(current[property], expect[property])) {
-            isEqual = false;
-            diffs.push({
-                property: property,
-                current: current[property],
-                expect: expect[property],
-            });
-        }
-    }
-    if (requireAllMatch &&
-        Object.keys(current).length !== Object.keys(expect).length) {
-        isEqual = false;
-        for (const property in current) {
-            if (expect[property] === undefined) {
-                diffs.push({
-                    property: property,
-                    current: current[property],
-                    expect: expect[property],
-                });
-            }
-        }
-    }
-    return { isEqual, diffs };
-};
-const compareStyle = (received, expectedStyle, config) => {
-    if (!received.props.style) {
-        return { message: () => message, pass: false };
-    }
-    const { exact } = config;
-    const currentStyle = getCurrentStyle(received);
-    const { isEqual, diffs } = findStyleDiff(currentStyle, expectedStyle, exact);
-    if (isEqual) {
-        return { message: () => 'ok', pass: true };
-    }
-    const currentStyleStr = JSON.stringify(currentStyle);
-    const expectedStyleStr = JSON.stringify(expectedStyle);
-    const differences = diffs
-        .map((diff) => `- '${diff.property}' should be ${JSON.stringify(diff.expect)}, but is ${JSON.stringify(diff.current)}`)
-        .join('\n');
-    return {
-        message: () => `Expected: ${expectedStyleStr}\nReceived: ${currentStyleStr}\n\nDifferences:\n${differences}`,
-        pass: false,
-    };
-};
-let frameTime = 1000 / config.fps;
-let requestAnimationFrameCopy;
-let currentTimestamp = 0;
-const requestAnimationFrame = (callback) => {
-    setTimeout(callback, frameTime);
-};
-const beforeTest = () => {
-    jestResetJsReanimatedModule();
-    requestAnimationFrameCopy = global.requestAnimationFrame;
-    global.requestAnimationFrame = requestAnimationFrame;
-    global.ReanimatedDataMock = {
-        now: () => currentTimestamp,
-    };
-    currentTimestamp = 0;
-    jest.useFakeTimers();
-};
-const afterTest = () => {
-    jest.useRealTimers();
-    global.requestAnimationFrame = requestAnimationFrameCopy;
-};
-const tickTravel = () => {
-    currentTimestamp += frameTime;
-    jest.advanceTimersByTime(frameTime);
-};
-export const withReanimatedTimer = (animatonTest) => {
-    beforeTest();
-    animatonTest();
-    afterTest();
-};
-export const advanceAnimationByTime = (time = frameTime) => {
-    for (let i = 0; i <= Math.ceil(time / frameTime); i++) {
-        tickTravel();
-    }
-    jest.advanceTimersByTime(frameTime);
-};
-export const advanceAnimationByFrame = (count) => {
-    for (let i = 0; i <= count; i++) {
-        tickTravel();
-    }
-    jest.advanceTimersByTime(frameTime);
-};
-export const setUpTests = (userConfig = {}) => {
-    const expect = require('expect');
-    require('setimmediate');
-    frameTime = Math.round(1000 / config.fps);
-    config = Object.assign(Object.assign({}, config), userConfig);
-    expect.extend({
-        toHaveAnimatedStyle(received, expectedStyle, config = {}) {
-            return compareStyle(received, expectedStyle, config);
-        },
-    });
-};
-export const getAnimatedStyle = (received) => {
-    return getCurrentStyle(received);
-};

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

@@ -1,99 +0,0 @@
-import MapperRegistry from './MapperRegistry';
-import Mapper from './Mapper';
-import MutableValue from './MutableValue';
-import { NativeReanimated } from '../NativeReanimated/NativeReanimated';
-import { isJest } from '../PlatformChecker';
-export default class JSReanimated extends NativeReanimated {
-    constructor() {
-        super(false);
-        this._valueSetter = undefined;
-        this._renderRequested = false;
-        this._mapperRegistry = new MapperRegistry(this);
-        this._frames = [];
-        if (isJest()) {
-            this.timeProvider = { now: () => global.ReanimatedDataMock.now() };
-        }
-        else {
-            this.timeProvider = { now: () => window.performance.now() };
-        }
-    }
-    pushFrame(frame) {
-        this._frames.push(frame);
-        this.maybeRequestRender();
-    }
-    getTimestamp() {
-        return this.timeProvider.now();
-    }
-    maybeRequestRender() {
-        if (!this._renderRequested) {
-            this._renderRequested = true;
-            requestAnimationFrame((_timestampMs) => {
-                this._renderRequested = false;
-                this._onRender(this.getTimestamp());
-            });
-        }
-    }
-    _onRender(timestampMs) {
-        this._mapperRegistry.execute();
-        const frames = [...this._frames];
-        this._frames = [];
-        for (let i = 0, len = frames.length; i < len; ++i) {
-            frames[i](timestampMs);
-        }
-        if (this._mapperRegistry.needRunOnRender) {
-            this._mapperRegistry.execute();
-        }
-    }
-    installCoreFunctions(valueSetter) {
-        this._valueSetter = valueSetter;
-    }
-    makeShareable(value) {
-        return value;
-    }
-    makeMutable(value) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return new MutableValue(value, this._valueSetter);
-    }
-    makeRemote(object = {}) {
-        return object;
-    }
-    startMapper(mapper, inputs = [], outputs = []) {
-        const instance = new Mapper(this, mapper, inputs, outputs);
-        const mapperId = this._mapperRegistry.startMapper(instance);
-        this.maybeRequestRender();
-        return mapperId;
-    }
-    stopMapper(mapperId) {
-        this._mapperRegistry.stopMapper(mapperId);
-    }
-    registerEventHandler(_, __) {
-        // noop
-        return '';
-    }
-    unregisterEventHandler(_) {
-        // noop
-    }
-    enableLayoutAnimations() {
-        console.warn('[Reanimated] enableLayoutAnimations is not available for WEB yet');
-    }
-    registerSensor() {
-        console.warn('[Reanimated] useAnimatedSensor is not available on web yet.');
-        return -1;
-    }
-    unregisterSensor() {
-        // noop
-    }
-    jestResetModule() {
-        if (isJest()) {
-            /**
-             * If someone used timers to stop animation before the end,
-             * then _renderRequested was set as true
-             * and any new update from another test wasn't applied.
-             */
-            this._renderRequested = false;
-        }
-        else {
-            throw Error('This method can be only use in Jest testing.');
-        }
-    }
-}