@ugo-studio/jspp 0.3.0 → 0.3.1

package/src/prelude/values/array.hpp

@@ -13,6 +13,7 @@ namespace jspp
         std::vector<AnyValue> dense;                     // dense storage for small/contiguous indices
         std::unordered_map<uint32_t, AnyValue> sparse;   // sparse indices (very large indices)
         std::unordered_map<std::string, AnyValue> props; // non-index string properties
+        std::map<AnyValue, AnyValue> symbol_props;
         AnyValue proto;
         uint64_t length = 0;
 
@@ -25,10 +26,13 @@ namespace jspp
         std::string to_std_string() const;
 
         bool has_property(const std::string &key) const;
+        bool has_symbol_property(const AnyValue &key) const;
         AnyValue get_property(const std::string &key, const AnyValue &thisVal);
         AnyValue get_property(uint32_t idx);
+        AnyValue get_symbol_property(const AnyValue &key, const AnyValue &thisVal);
         AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
         AnyValue set_property(uint32_t idx, const AnyValue &value);
+        AnyValue set_symbol_property(const AnyValue &key, const AnyValue &value, const AnyValue &thisVal);
 
         static bool is_array_index(const std::string &s)
         {

package/src/prelude/values/async_iterator.cpp

@@ -0,0 +1,251 @@
+#include "jspp.hpp"
+#include "values/async_iterator.hpp"
+#include "values/prototypes/async_iterator.hpp"
+
+namespace jspp {
+
+template <typename T>
+JsAsyncIterator<T>::JsAsyncIterator(handle_type h) : handle(h) {}
+
+template <typename T>
+JsAsyncIterator<T>::JsAsyncIterator(JsAsyncIterator &&other) noexcept 
+    : handle(std::exchange(other.handle, nullptr)),
+      props(std::move(other.props)),
+      symbol_props(std::move(other.symbol_props)) {}
+
+template <typename T>
+JsAsyncIterator<T>::~JsAsyncIterator() { if (handle) handle.destroy(); }
+
+template <typename T>
+JsAsyncIterator<T> JsAsyncIterator<T>::promise_type::get_return_object() {
+    return JsAsyncIterator{std::coroutine_handle<promise_type>::from_promise(*this)};
+}
+
+template <typename T>
+std::suspend_always JsAsyncIterator<T>::promise_type::initial_suspend() noexcept { return {}; }
+
+template <typename T>
+std::suspend_always JsAsyncIterator<T>::promise_type::final_suspend() noexcept { return {}; }
+
+template <typename T>
+bool JsAsyncIterator<T>::promise_type::YieldAwaiter::await_ready() { return false; }
+
+template <typename T>
+void JsAsyncIterator<T>::promise_type::YieldAwaiter::await_suspend(std::coroutine_handle<promise_type> h) {}
+
+template <typename T>
+T JsAsyncIterator<T>::promise_type::YieldAwaiter::await_resume() { return p.current_input; }
+
+template <typename T>
+void 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>
+bool JsAsyncIterator<T>::promise_type::AsyncIterAwaiter::await_ready() { return base_awaiter.await_ready(); }
+
+template <typename T>
+void JsAsyncIterator<T>::promise_type::AsyncIterAwaiter::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;
+        }
+    );
+}
+
+template <typename T>
+AnyValue JsAsyncIterator<T>::promise_type::AsyncIterAwaiter::await_resume() { return base_awaiter.await_resume(); }
+
+template <typename T>
+typename JsAsyncIterator<T>::promise_type::AsyncIterAwaiter JsAsyncIterator<T>::promise_type::await_transform(AnyValue value) {
+    is_awaiting = true;
+    return AsyncIterAwaiter{AnyValueAwaiter{std::move(value)}, *this};
+}
+
+template <typename T>
+std::string JsAsyncIterator<T>::to_std_string() const { return "[object AsyncGenerator]"; }
+
+template <typename T>
+void 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;
+    if (!p.pending_calls.empty() && !p.is_awaiting && !handle.done()) {
+        this->ref();
+        Scheduler::instance().enqueue([this]() { this->resume_next(); this->deref(); });
+    }
+}
+
+template <typename T>
+JsPromise JsAsyncIterator<T>::next(const T &val)
+{
+    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;
+}
+
+template <typename T>
+bool JsAsyncIterator<T>::has_symbol_property(const AnyValue &key) const { return symbol_props.count(key) > 0; }
+
+template <typename T>
+AnyValue 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>
+AnyValue JsAsyncIterator<T>::get_symbol_property(const AnyValue &key, AnyValue thisVal)
+{
+    auto it = symbol_props.find(key);
+    if (it == symbol_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.to_std_string());
+        }
+        return Constants::UNDEFINED;
+    }
+    return AnyValue::resolve_property_for_read(it->second, thisVal, key.to_std_string());
+}
+
+template <typename T>
+AnyValue 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>
+AnyValue JsAsyncIterator<T>::set_symbol_property(const AnyValue &key, AnyValue value, AnyValue thisVal)
+{
+    auto it = symbol_props.find(key);
+    if (it != symbol_props.end()) return AnyValue::resolve_property_for_write(it->second, thisVal, value, key.to_std_string());
+    else { symbol_props[key] = value; return value; }
+}
+
+// Explicit template instantiation
+template class JsAsyncIterator<AnyValue>;
+
+namespace AsyncIteratorPrototypes {
+
+AnyValue &get_toString_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                 { return AnyValue::make_string(thisVal.as_async_iterator()->to_std_string()); },
+                                                 "toString");
+    return fn;
+}
+
+AnyValue &get_asyncIterator_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                 { return thisVal; },
+                                                 "Symbol.asyncIterator");
+    return fn;
+}
+
+AnyValue &get_next_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
+                                                     auto res = thisVal.as_async_iterator()->next(val);
+                                                     return AnyValue::make_promise(res); },
+                                                 "next");
+    return fn;
+}
+
+std::optional<AnyValue> get(const std::string &key)
+{
+    if (key == "toString") return get_toString_fn();
+    if (key == "next") return get_next_fn();
+    return std::nullopt;
+}
+
+std::optional<AnyValue> get(const AnyValue &key)
+{
+    if (key.is_string())
+        return get(key.as_string()->value);
+
+    if (key == AnyValue::from_symbol(WellKnownSymbols::toStringTag)) return get_toString_fn();
+    if (key == AnyValue::from_symbol(WellKnownSymbols::asyncIterator)) return get_asyncIterator_fn();
+    if (key == "next") return get_next_fn();
+
+    return std::nullopt;
+}
+
+} // namespace AsyncIteratorPrototypes
+
+} // namespace jspp

package/src/prelude/values/async_iterator.hpp

@@ -4,16 +4,12 @@
 #include <coroutine>
 #include <optional>
 #include <queue>
-#include <iostream>
-#include <utility>
-#include <exception>
-#include "values/promise.hpp"
-#include "scheduler.hpp"
+#include <vector>
 
 namespace jspp
 {
-    // Forward declaration of AnyValue
     class AnyValue;
+    struct JsPromise;
 
     template <typename T>
     class JsAsyncIterator : public HeapObject
@@ -28,55 +24,87 @@ namespace jspp
             bool is_running = false;
             T current_input;
 
-            JsAsyncIterator get_return_object()
-            {
-                return JsAsyncIterator{
-                    std::coroutine_handle<promise_type>::from_promise(*this)};
-            }
+            JsAsyncIterator get_return_object();
+            std::suspend_always initial_suspend() noexcept;
+            std::suspend_always final_suspend() noexcept;
 
-            std::suspend_always initial_suspend() noexcept { return {}; }
-
-            std::suspend_always final_suspend() noexcept { return {}; }
+            struct YieldAwaiter
+            {
+                promise_type &p;
+                bool await_ready();
+                void await_suspend(std::coroutine_handle<promise_type> h);
+                T await_resume();
+            };
 
-            // Declarations
             template <typename From>
-            auto yield_value(From &&from);
+            YieldAwaiter 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);
+                }
+                return YieldAwaiter{*this};
+            }
 
             template <typename From>
-            void return_value(From &&from);
+            void 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);
+                }
+            }
 
             void unhandled_exception();
+            
+            void fail_all(const AnyValue &reason) {
+                while (!pending_calls.empty()) {
+                    auto call = pending_calls.front();
+                    pending_calls.pop();
+                    call.first.reject(reason);
+                }
+            }
 
-            void fail_all(const AnyValue &reason);
+            struct AsyncIterAwaiter
+            {
+                AnyValueAwaiter base_awaiter;
+                promise_type &p_ref;
+
+                bool await_ready();
+                void await_suspend(std::coroutine_handle<promise_type> h);
+                AnyValue await_resume();
+            };
 
-            auto await_transform(AnyValue value);
+            AsyncIterAwaiter await_transform(AnyValue value);
         };
 
         using handle_type = std::coroutine_handle<promise_type>;
         handle_type handle;
 
-        explicit JsAsyncIterator(handle_type h) : handle(h) {}
-        JsAsyncIterator(JsAsyncIterator &&other) noexcept 
-            : handle(std::exchange(other.handle, nullptr)),
-              props(std::move(other.props)) {}
-
+        explicit JsAsyncIterator(handle_type h);
+        JsAsyncIterator(JsAsyncIterator &&other) noexcept;
         JsAsyncIterator(const JsAsyncIterator &) = delete;
         JsAsyncIterator &operator=(const JsAsyncIterator &) = delete;
-
-        ~JsAsyncIterator()
-        {
-            if (handle)
-                handle.destroy();
-        }
+        ~JsAsyncIterator();
 
         std::unordered_map<std::string, AnyValue> props;
+        std::map<AnyValue, AnyValue> symbol_props;
 
         std::string to_std_string() const;
-
         JsPromise next(const T &val = T());
-
+        bool has_symbol_property(const AnyValue &key) const;
         AnyValue get_property(const std::string &key, AnyValue thisVal);
+        AnyValue get_symbol_property(const AnyValue &key, AnyValue thisVal);
         AnyValue set_property(const std::string &key, AnyValue value, AnyValue thisVal);
+        AnyValue set_symbol_property(const AnyValue &key, AnyValue value, AnyValue thisVal);
 
         void resume_next();
     };

package/src/prelude/values/function.cpp

@@ -0,0 +1,262 @@
+#include "jspp.hpp"
+#include "values/function.hpp"
+#include "values/prototypes/function.hpp"
+
+namespace jspp {
+
+// --- JsFunction Implementation ---
+
+JsFunction::JsFunction(const JsFunctionCallable &c,
+                        std::optional<std::string> n,
+                        std::unordered_map<std::string, AnyValue> p,
+                        std::map<AnyValue, AnyValue> sp,
+                        bool is_cls,
+                        bool is_ctor)
+    : callable(c),
+        name(std::move(n)),
+        props(std::move(p)),
+        symbol_props(std::move(sp)),
+        proto(Constants::Null),
+        is_generator(callable.index() == 1),
+        is_async(callable.index() == 2),
+        is_class(is_cls),
+        is_constructor(is_ctor && !is_generator && !is_async)
+{
+}
+
+JsFunction::JsFunction(const JsFunctionCallable &c,
+                        bool is_gen,
+                        std::optional<std::string> n,
+                        std::unordered_map<std::string, AnyValue> p,
+                        std::map<AnyValue, AnyValue> sp,
+                        bool is_cls,
+                        bool is_ctor)
+    : callable(c),
+        name(std::move(n)),
+        props(std::move(p)),
+        symbol_props(std::move(sp)),
+        proto(Constants::Null),
+        is_generator(is_gen),
+        is_async(callable.index() == 2),
+        is_class(is_cls),
+        is_constructor(is_ctor && !is_gen && !is_async)
+{
+}
+
+JsFunction::JsFunction(const JsFunctionCallable &c,
+                        bool is_gen,
+                        bool is_async_func,
+                        std::optional<std::string> n,
+                        std::unordered_map<std::string, AnyValue> p,
+                        std::map<AnyValue, AnyValue> sp,
+                        bool is_cls,
+                        bool is_ctor)
+    : callable(c),
+        name(std::move(n)),
+        props(std::move(p)),
+        symbol_props(std::move(sp)),
+        proto(Constants::Null),
+        is_generator(is_gen),
+        is_async(is_async_func),
+        is_class(is_cls),
+        is_constructor(is_ctor && !is_gen && !is_async_func)
+{
+}
+
+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] }";
+}
+
+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::from_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;
+    }
+}
+
+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;
+}
+
+bool JsFunction::has_symbol_property(const AnyValue &key) const
+{
+    if (symbol_props.count(key))
+        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;
+}
+
+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);
+}
+
+AnyValue JsFunction::get_symbol_property(const AnyValue &key, AnyValue thisVal)
+{
+    auto it = symbol_props.find(key);
+    if (it == symbol_props.end())
+    {
+        if (!proto.is_null() && !proto.is_undefined())
+        {
+            auto res = proto.get_symbol_property_with_receiver(key, thisVal);
+            if (!res.is_undefined())
+                return res;
+        }
+
+        auto proto_it = FunctionPrototypes::get(key);
+        if (proto_it.has_value())
+        {
+            return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key.to_std_string());
+        }
+        return Constants::UNDEFINED;
+    }
+    return AnyValue::resolve_property_for_read(it->second, thisVal, key.to_std_string());
+}
+
+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;
+    }
+}
+
+AnyValue JsFunction::set_symbol_property(const AnyValue &key, AnyValue value, AnyValue thisVal)
+{
+    auto it = symbol_props.find(key);
+    if (it != symbol_props.end())
+    {
+        return AnyValue::resolve_property_for_write(it->second, thisVal, value, key.to_std_string());
+    }
+    else
+    {
+        symbol_props[key] = value;
+        return value;
+    }
+}
+
+// --- FunctionPrototypes Implementation ---
+
+namespace FunctionPrototypes {
+
+AnyValue &get_toString_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
+                                                 { return AnyValue::make_string(thisVal.as_function()->to_std_string()); },
+                                                 "toString");
+    return fn;
+}
+
+AnyValue &get_call_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     AnyValue thisArg = Constants::UNDEFINED;
+                                                     std::span<const AnyValue> fnArgs;
+
+                                                     if (!args.empty())
+                                                     {
+                                                         thisArg = args[0];
+                                                         fnArgs = args.subspan(1);
+                                                     }
+
+                                                     return thisVal.call(thisArg, fnArgs); },
+                                                 "call");
+    return fn;
+}
+
+std::optional<AnyValue> get(const std::string &key)
+{
+    if (key == "toString") return get_toString_fn();
+    if (key == "call") return get_call_fn();
+    return std::nullopt;
+}
+
+std::optional<AnyValue> get(const AnyValue &key)
+{
+    if (key.is_string())
+        return get(key.as_string()->value);
+
+    if (key == AnyValue::from_symbol(WellKnownSymbols::toStringTag)) return get_toString_fn();
+    if (key == "call") return get_call_fn();
+    return std::nullopt;
+}
+
+} // namespace FunctionPrototypes
+
+} // namespace jspp