javascript.h

#ifndef OE_EXT_JAVASCRIPT_H
#define OE_EXT_JAVASCRIPT_H
 
#include <OxygenEngine/lib/json.hpp>
#include <OxygenEngine/io/logger.h>
 
namespace oe::ext::js
{
    struct CallableEntity
    {
        std::string name; 
        duk_c_function callback; 
        duk_idx_t callback_args_count = 0; 
    };
 
    struct Runtime
    {
        Runtime()
        {
            ctx = duk_create_heap_default();
        }
 
        ~Runtime()
        {
            duk_destroy_heap(ctx);
        }
 
        void addClass(CallableEntity class_info, const std::vector<CallableEntity>& methods)
        {
            duk_push_c_function(ctx, class_info.callback, class_info.callback_args_count);
 
            duk_push_object(ctx);
 
            for (auto&& it : methods)
            {
                duk_push_c_function(ctx, it.callback, it.callback_args_count);
                duk_put_prop_string(ctx, -2, it.name.c_str());
            }
 
            duk_put_prop_string(ctx, -2, "prototype");
 
            duk_put_global_string(ctx, class_info.name.c_str());
        }
 
        void addFunction(CallableEntity function_info)
        {
            duk_push_c_function(ctx, function_info.callback, function_info.callback_args_count);
            duk_put_global_string(ctx, function_info.name.c_str());
        }
 
        static void pushJson(duk_context* ctx, const nlohmann::json& data, bool is_object = true)
        {
            auto obj_idx = is_object
                ? duk_push_object(ctx)
                : duk_push_array(ctx)
            ;
 
            for (auto& it : data.items())
            {
                duk_push_string(ctx, it.key().c_str());
 
                const auto& value = it.value();
 
                if (value.is_object())
                {
                    pushJson(ctx, value);
                }
                else if (value.is_array())
                {
                    pushJson(ctx, value, false);
                }
                else if (value.is_string())
                {
                    duk_push_string(ctx, value.get<std::string>().c_str());
                }
                else if (value.is_boolean())
                {
                    duk_push_boolean(ctx, value.get<bool>());
                }
                else if (value.is_number_integer())
                {
                    duk_push_int(ctx, value.get<int32_t>());
                }
                else if (value.is_number_float())
                {
                    duk_push_number(ctx, value.get<float>());
                }
                else
                {
                    duk_push_null(ctx);
                }
 
                duk_put_prop(ctx, obj_idx);
            }
        }
 
        static nlohmann::json getJson(duk_context *ctx, int index)
        {
            return nlohmann::json::parse(duk_json_encode(ctx, index));
        }
 
        void eval(const char* data)
        {
            if (duk_peval_string(ctx, data) != 0)
            {
                oe::log.critical() << "Error: " << duk_safe_to_string(ctx, -1);
            }
            duk_pop(ctx);
        }
 
        duk_context* ctx;
    };
}
 
#endif