@ugo-studio/jspp 0.2.9 → 0.3.1

package/src/prelude/values/helpers/async_iterator.hpp

@@ -1,275 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/async_iterator.hpp"
-#include "any_value.hpp"
-#include "values/prototypes/async_iterator.hpp"
-
-// --- JsAsyncIterator methods ---
-
-template <typename T>
-std::string jspp::JsAsyncIterator<T>::to_std_string() const
-{
-    return "[object AsyncGenerator]";
-}
-
-template <typename T>
-jspp::AnyValue jspp::JsAsyncIterator<T>::get_property(const std::string &key, AnyValue thisVal)
-{
-    auto it = props.find(key);
-    if (it == props.end())
-    {
-        if constexpr (std::is_same_v<T, AnyValue>)
-        {
-            auto proto_it = AsyncIteratorPrototypes::get(key);
-            if (proto_it.has_value())
-            {
-                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
-            }
-        }
-        return Constants::UNDEFINED;
-    }
-    return AnyValue::resolve_property_for_read(it->second, thisVal, key);
-}
-
-template <typename T>
-jspp::AnyValue jspp::JsAsyncIterator<T>::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
-{
-    if constexpr (std::is_same_v<T, AnyValue>)
-    {
-        auto proto_it = AsyncIteratorPrototypes::get(key);
-        if (proto_it.has_value())
-        {
-            auto proto_value = proto_it.value();
-            if (proto_value.is_accessor_descriptor())
-            {
-                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
-            }
-            if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable)
-            {
-                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
-            }
-        }
-    }
-
-    auto it = props.find(key);
-    if (it != props.end())
-    {
-        return jspp::AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
-    }
-    else
-    {
-        props[key] = value;
-        return value;
-    }
-}
-
-template <typename T>
-void jspp::JsAsyncIterator<T>::resume_next()
-{
-    if (!handle || handle.done())
-        return;
-    auto &p = handle.promise();
-    if (p.is_awaiting || p.is_running)
-        return;
-    if (p.pending_calls.empty())
-        return;
-
-    p.is_running = true;
-
-    auto &next_call = p.pending_calls.front();
-    p.current_input = next_call.second;
-
-    handle.resume();
-
-    p.is_running = false;
-
-    // After yield/return, if more calls are pending, handle them.
-    if (!p.pending_calls.empty() && !p.is_awaiting && !handle.done())
-    {
-        this->ref();
-        Scheduler::instance().enqueue([this]()
-                                      { 
-                                          this->resume_next(); 
-                                          this->deref();
-                                      });
-    }
-}
-
-template <typename T>
-jspp::JsPromise jspp::JsAsyncIterator<T>::next(const T &val)
-{
-    // JsPromise is now a HeapObject.
-    // We should return it by value (which AnyValue will then wrap).
-    // Wait, coroutines return JsPromise by value.
-    JsPromise p;
-    if (handle)
-    {
-        if (handle.done())
-        {
-            p.resolve(AnyValue::make_object({{"value", Constants::UNDEFINED}, {"done", Constants::TRUE}}));
-        }
-        else
-        {
-            handle.promise().pending_calls.push({p, val});
-            resume_next();
-        }
-    }
-    else
-    {
-        p.resolve(AnyValue::make_object({{"value", Constants::UNDEFINED}, {"done", Constants::TRUE}}));
-    }
-    return p;
-}
-
-// --- JsAsyncIterator::promise_type methods ---
-
-template <typename T>
-template <typename From>
-auto jspp::JsAsyncIterator<T>::promise_type::yield_value(From &&from)
-{
-    if (!pending_calls.empty())
-    {
-        auto call = pending_calls.front();
-        pending_calls.pop();
-        AnyValue result = AnyValue::make_object({{"value", std::forward<From>(from)}, {"done", Constants::FALSE}});
-        call.first.resolve(result);
-    }
-
-    struct YieldAwaiter
-    {
-        promise_type &p;
-        bool await_ready() { return false; }
-        void await_suspend(std::coroutine_handle<promise_type> h)
-        {
-            // Suspended at yield.
-        }
-        T await_resume() { return p.current_input; }
-    };
-    return YieldAwaiter{*this};
-}
-
-template <typename T>
-template <typename From>
-void jspp::JsAsyncIterator<T>::promise_type::return_value(From &&from)
-{
-    if (!pending_calls.empty())
-    {
-        auto call = pending_calls.front();
-        pending_calls.pop();
-        AnyValue result = AnyValue::make_object({{"value", std::forward<From>(from)}, {"done", Constants::TRUE}});
-        call.first.resolve(result);
-    }
-
-    while (!pending_calls.empty())
-    {
-        auto call = pending_calls.front();
-        pending_calls.pop();
-        AnyValue result = AnyValue::make_object({{"value", Constants::UNDEFINED}, {"done", Constants::TRUE}});
-        call.first.resolve(result);
-    }
-}
-
-template <typename T>
-void jspp::JsAsyncIterator<T>::promise_type::fail_all(const AnyValue &reason)
-{
-    while (!pending_calls.empty())
-    {
-        auto call = pending_calls.front();
-        pending_calls.pop();
-        call.first.reject(reason);
-    }
-}
-
-template <typename T>
-void jspp::JsAsyncIterator<T>::promise_type::unhandled_exception()
-{
-    try
-    {
-        std::rethrow_exception(std::current_exception());
-    }
-    catch (const Exception &e)
-    {
-        fail_all(e.data);
-    }
-    catch (const std::exception &e)
-    {
-        fail_all(AnyValue::make_string(e.what()));
-    }
-    catch (...)
-    {
-        fail_all(AnyValue::make_string("Unknown error in async generator"));
-    }
-}
-
-template <typename T>
-auto jspp::JsAsyncIterator<T>::promise_type::await_transform(AnyValue value)
-{
-    is_awaiting = true;
-    struct AsyncIterAwaiter
-    {
-        AnyValueAwaiter base_awaiter;
-        promise_type &p_ref;
-
-        bool await_ready() { return base_awaiter.await_ready(); }
-        void await_suspend(std::coroutine_handle<promise_type> h)
-        {
-            if (!base_awaiter.value.is_promise())
-            {
-                jspp::Scheduler::instance().enqueue([h]() mutable
-                                              {
-                    auto &pr = h.promise();
-                    pr.is_awaiting = false;
-                    pr.is_running = true;
-                    h.resume();
-                    pr.is_running = false;
-
-                    if (!h.done() && !pr.is_awaiting && !pr.pending_calls.empty())
-                    {
-                        while (!h.done() && !pr.is_awaiting && !pr.pending_calls.empty())
-                        {
-                            pr.is_running = true;
-                            pr.current_input = pr.pending_calls.front().second;
-                            h.resume();
-                            pr.is_running = false;
-                        }
-                    } });
-                return;
-            }
-            auto p = base_awaiter.value.as_promise();
-            p->then(
-                [h](AnyValue v) mutable
-                {
-                    auto &pr = h.promise();
-                    pr.is_awaiting = false;
-                    pr.is_running = true;
-                    h.resume();
-                    pr.is_running = false;
-
-                    if (!h.done() && !pr.is_awaiting && !pr.pending_calls.empty())
-                    {
-                        while (!h.done() && !pr.is_awaiting && !pr.pending_calls.empty())
-                        {
-                            pr.is_running = true;
-                            pr.current_input = pr.pending_calls.front().second;
-                            h.resume();
-                            pr.is_running = false;
-                        }
-                    }
-                },
-                [h](AnyValue e) mutable
-                {
-                    auto &pr = h.promise();
-                    pr.is_awaiting = false;
-                    pr.is_running = true;
-                    h.resume();
-                    pr.is_running = false;
-                });
-        }
-        AnyValue await_resume()
-        {
-            return base_awaiter.await_resume();
-        }
-    };
-    return AsyncIterAwaiter{AnyValueAwaiter{std::move(value)}, *this};
-}

package/src/prelude/values/helpers/function.hpp

@@ -1,109 +0,0 @@
-#pragma once
-
-#include <variant>
-#include <optional>
-
-#include "types.hpp"
-#include "values/function.hpp"
-#include "any_value.hpp"
-#include "values/prototypes/function.hpp"
-
-namespace jspp
-{
-    inline std::string JsFunction::to_std_string() const
-    {
-        std::string type_part = this->is_async ? "async function" : this->is_generator ? "function*"
-                                                                                       : "function";
-        std::string name_part = this->name.value_or("");
-        return type_part + " " + name_part + "() { [native code] }";
-    }
-
-    inline AnyValue JsFunction::call(AnyValue thisVal, std::span<const AnyValue> args)
-    {
-        if (std::function<AnyValue(AnyValue, std::span<const AnyValue>)> *func = std::get_if<0>(&callable))
-        {
-            return (*func)(thisVal, args);
-        }
-        else if (std::function<jspp::JsIterator<jspp::AnyValue>(AnyValue, std::vector<AnyValue>)> *func = std::get_if<1>(&callable))
-        {
-            return AnyValue::from_iterator((*func)(thisVal, std::vector<AnyValue>(args.begin(), args.end())));
-        }
-        else if (std::function<jspp::JsPromise(AnyValue, std::vector<AnyValue>)> *func = std::get_if<2>(&callable))
-        {
-            return AnyValue::make_promise((*func)(thisVal, std::vector<AnyValue>(args.begin(), args.end())));
-        }
-        else if (std::function<jspp::JsAsyncIterator<jspp::AnyValue>(AnyValue, std::vector<AnyValue>)> *func = std::get_if<3>(&callable))
-        {
-            return AnyValue::from_async_iterator((*func)(thisVal, std::vector<AnyValue>(args.begin(), args.end())));
-        }
-        else
-        {
-            return Constants::UNDEFINED;
-        }
-    }
-
-    inline bool JsFunction::has_property(const std::string &key) const
-    {
-        if (props.find(key) != props.end())
-            return true;
-        if (!proto.is_null() && !proto.is_undefined())
-        {
-            if (proto.has_property(key))
-                return true;
-        }
-        if (FunctionPrototypes::get(key).has_value())
-            return true;
-        return false;
-    }
-
-    inline AnyValue JsFunction::get_property(const std::string &key, AnyValue thisVal)
-    {
-        auto it = props.find(key);
-        if (it == props.end())
-        {
-            if (!proto.is_null() && !proto.is_undefined())
-            {
-                if (proto.has_property(key))
-                {
-                    return proto.get_property_with_receiver(key, thisVal);
-                }
-            }
-
-            auto proto_it = FunctionPrototypes::get(key);
-            if (proto_it.has_value())
-            {
-                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
-            }
-            return Constants::UNDEFINED;
-        }
-        return AnyValue::resolve_property_for_read(it->second, thisVal, key);
-    }
-
-    inline AnyValue JsFunction::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
-    {
-        auto proto_it = FunctionPrototypes::get(key);
-        if (proto_it.has_value())
-        {
-            auto proto_value = proto_it.value();
-            if (proto_value.is_accessor_descriptor())
-            {
-                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
-            }
-            if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable)
-            {
-                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
-            }
-        }
-
-        auto it = props.find(key);
-        if (it != props.end())
-        {
-            return AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
-        }
-        else
-        {
-            props[key] = value;
-            return value;
-        }
-    }
-}

package/src/prelude/values/helpers/iterator.hpp

@@ -1,145 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/iterator.hpp"
-#include "any_value.hpp"
-#include "values/prototypes/iterator.hpp"
-
-template <typename T>
-std::string jspp::JsIterator<T>::to_std_string() const
-{
-    return "[object Generator]";
-}
-
-template <typename T>
-typename jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::next(const T &val)
-{
-    // If the generator is already finished or invalid, return {undefined, true}
-    if (!handle || handle.done())
-        return {std::nullopt, true};
-
-    handle.promise().input_value = val;
-
-    // Resume execution until next co_yield or co_return
-    handle.resume();
-
-    if (handle.promise().exception_)
-    {
-        std::rethrow_exception(handle.promise().exception_);
-    }
-
-    // If handle.done() is TRUE, we hit co_return (value: X, done: true)
-    // If handle.done() is FALSE, we hit co_yield (value: X, done: false)
-    bool is_done = handle.done();
-
-    return {handle.promise().current_value, is_done};
-}
-
-template <typename T>
-typename jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::return_(const T &val)
-{
-    if (!handle || handle.done())
-        return {val, true};
-
-    handle.promise().pending_return = true;
-    handle.promise().current_value = val;
-    handle.resume();
-
-    if (handle.promise().exception_)
-    {
-        std::rethrow_exception(handle.promise().exception_);
-    }
-
-    return {handle.promise().current_value, true};
-}
-
-template <typename T>
-typename jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::throw_(const AnyValue &err)
-{
-    if (!handle || handle.done()) {
-        throw Exception(err);
-    }
-
-    handle.promise().pending_exception = std::make_exception_ptr(Exception(err));
-    handle.resume();
-
-    if (handle.promise().exception_)
-    {
-        std::rethrow_exception(handle.promise().exception_);
-    }
-
-    bool is_done = handle.done();
-    return {handle.promise().current_value, is_done};
-}
-
-template <typename T>
-std::vector<T> jspp::JsIterator<T>::to_vector()
-{
-    std::vector<T> result;
-    while (true)
-    {
-        auto next_res = this->next();
-        if (next_res.done)
-        {
-            break;
-        }
-        result.push_back(next_res.value.value_or(Constants::UNDEFINED));
-    }
-    return result;
-}
-
-template <typename T>
-jspp::AnyValue jspp::JsIterator<T>::get_property(const std::string &key, AnyValue thisVal)
-{
-    auto it = props.find(key);
-    if (it == props.end())
-    {
-        // check prototype
-        if constexpr (std::is_same_v<T, AnyValue>)
-        {
-            auto proto_it = IteratorPrototypes::get(key);
-            if (proto_it.has_value())
-            {
-                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
-            }
-        }
-        // prototype not found
-        return Constants::UNDEFINED;
-    }
-
-    return AnyValue::resolve_property_for_read(it->second, thisVal, key);
-}
-
-template <typename T>
-jspp::AnyValue jspp::JsIterator<T>::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
-{
-    // set prototype property if accessor descriptor
-    if constexpr (std::is_same_v<T, AnyValue>)
-    {
-        auto proto_it = IteratorPrototypes::get(key);
-        if (proto_it.has_value())
-        {
-            auto proto_value = proto_it.value();
-            if (proto_value.is_accessor_descriptor())
-            {
-                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
-            }
-            if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable)
-            {
-                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
-            }
-        }
-    }
-
-    // set own property
-    auto it = props.find(key);
-    if (it != props.end())
-    {
-        return jspp::AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
-    }
-    else
-    {
-        props[key] = value;
-        return value;
-    }
-}

package/src/prelude/values/helpers/object.hpp

@@ -1,104 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/object.hpp"
-#include "any_value.hpp"
-
-namespace jspp {
-    inline JsObject::JsObject() : shape(Shape::empty_shape()), proto(Constants::Null) {}
-
-    inline JsObject::JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, AnyValue pr) : proto(pr) {
-        shape = Shape::empty_shape();
-        storage.reserve(p.size());
-        for (const auto& pair : p) {
-            shape = shape->transition(pair.first);
-            storage.push_back(pair.second);
-        }
-    }
-
-    inline JsObject::JsObject(const std::map<std::string, AnyValue> &p, AnyValue pr) : proto(pr) {
-        shape = Shape::empty_shape();
-        storage.reserve(p.size());
-        for (const auto& pair : p) {
-            shape = shape->transition(pair.first);
-            storage.push_back(pair.second);
-        }
-    }
-}
-
-inline std::string jspp::JsObject::to_std_string() const
-{
-    return "[Object Object]";
-}
-
-inline bool jspp::JsObject::has_property(const std::string &key) const
-{
-    if (deleted_keys.count(key)) return false;
-
-    if (shape->get_offset(key).has_value())
-        return true;
-    if (!proto.is_null() && !proto.is_undefined())
-    {
-        if (proto.has_property(key))
-            return true;
-    }
-    if (ObjectPrototypes::get(key).has_value())
-        return true;
-    return false;
-}
-
-inline jspp::AnyValue jspp::JsObject::get_property(const std::string &key, const AnyValue &thisVal)
-{
-    if (deleted_keys.count(key)) return Constants::UNDEFINED;
-
-    auto offset = shape->get_offset(key);
-    if (!offset.has_value())
-    {
-        if (!proto.is_null() && !proto.is_undefined())
-        {
-            if (proto.has_property(key))
-            {
-                return proto.get_property_with_receiver(key, thisVal);
-            }
-        }
-
-        auto proto_it = ObjectPrototypes::get(key);
-        if (proto_it.has_value())
-        {
-            return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
-        }
-        return Constants::UNDEFINED;
-    }
-    return AnyValue::resolve_property_for_read(storage[offset.value()], thisVal, key);
-}
-
-inline jspp::AnyValue jspp::JsObject::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
-{
-    auto proto_it = ObjectPrototypes::get(key);
-    if (proto_it.has_value())
-    {
-        auto proto_value = proto_it.value();
-        if (proto_value.is_accessor_descriptor())
-        {
-            return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
-        }
-        if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable)
-        {
-            return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
-        }
-    }
-
-    if (deleted_keys.count(key)) deleted_keys.erase(key);
-
-    auto offset = shape->get_offset(key);
-    if (offset.has_value())
-    {
-        return AnyValue::resolve_property_for_write(storage[offset.value()], thisVal, value, key);
-    }
-    else
-    {
-        shape = shape->transition(key);
-        storage.push_back(value);
-        return value;
-    }
-}