RuntimeDecorator cleanup

[jwajgelt]

Summary

Reduces boilerplate around installing native JSI functions in RuntimeDecorator.

We need to install Host Functions into the JS runtimes that will be called by reanimated.
However, these functions need to use the JSI calling convention, which means having a signature jsi::Value(Runtime &runtime, jsi::Value const &thisValue, jsi::Value const *args, size_t count), but we want to write host functions with regular C++ functions (i.e. taking a specific number of typed and named arguments) instead.
The current solution for this problem is to wrap the host functions in lambdas which take the JSI arguments and convert them to the C++ ones, for example

  auto _scrollTo = [scrollTo](
                       jsi::Runtime &rt,
                       const jsi::Value &thisValue,
                       const jsi::Value *args,
                       const size_t count) -> jsi::Value {
    int viewTag = static_cast<int>(args[0].asNumber());
    double x = args[1].asNumber();
    double y = args[2].asNumber();
    bool animated = args[3].getBool();
    scrollTo(viewTag, x, y, animated);
    return jsi::Value::undefined();
  };

However, since almost the same code has to be written for each host function, this introduces a lot of similar boilerplate functions in RuntimeDecorator, reducing readability.

We'd like to instead have a generic solution, which can take a regular C++ std::function<ReturnType(ArgumentTypes...)> and create this wrapper for us.
This PR accomplishes that by implementing a generic function convertArgs<ArgumentTypes...>(jsi::Runtime &rt, const jsi::Value *args, const size_t count) which walks over the args, calls appropriate functions to cast them to the native C++ types ArgumentTypes... and returns a tuple with the result.
Then, this result is used by createJsiFunction(function) to wrap the function in a lambda which takes the JSI arguments, calls convertArgs on them, and calls the function with them.

This approach has some limitations:

• the conversion to native types is done using the T get<T>(jsi::Value const *) function, which is defined only for a few basic types. This restricts the argument types for host functions to only these types, but can easily be extended by specializing the get<T>(...) for the desired type.
• if the host function wants to access the Runtime, it must take Runtime & as its first parameter. This simplifies the conversion code (since we don't have to check for each argument if it's a value passed through JSI or the runtime), and seems like an acceptable trade-off.
• the host function cannot access the thisValue argument passed from JS. This isn't an issue in our use case, since the called functions are installed as globals.
• the host function cannot access args and count explicitly. As such, it's impossible to implement host functions which take a non-fixed number of arguments by checking the number of arguments passed from JS.
• the return type of the function must be either void (in which case jsi::Value::undefined()) or convertible to jsi::Value, in which case it is returned.

Test plan

Check that features depending on the host functions installed in RuntimeDecorator (i.e. basically everything) work like before.

[graszka22]

Nice templates 👍 I have just two questions