@ugo-studio/jspp 0.1.5 → 0.1.6

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

@@ -0,0 +1,275 @@
+#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, const 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, this);
+            if (proto_it.has_value())
+            {
+                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+            }
+        }
+        return AnyValue::make_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, const AnyValue &value, const AnyValue &thisVal)
+{
+    if constexpr (std::is_same_v<T, AnyValue>)
+    {
+        auto proto_it = AsyncIteratorPrototypes::get(key, this);
+        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())
+    {
+        Scheduler::instance().enqueue([this]()
+                                      { this->resume_next(); });
+    }
+}
+
+template <typename T>
+jspp::JsPromise jspp::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;
+}
+
+// --- 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", AnyValue::make_boolean(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;
+
+                    // After resume, if we suspended at a yield and have more calls, loop.
+                    if (!h.done() && !pr.is_awaiting && !pr.pending_calls.empty())
+                    {
+                        // We need to call resume_next, but we don't have the iterator.
+                        // Actually, the loop in resume_next handles this.
+                        // But wait, who calls resume_next?
+                        // If we are here, we are in a microtask.
+                        // Let's just manually continue if needed.
+                        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;
+                    // Errors handled via await_resume/exception throw
+                });
+        }
+        AnyValue await_resume()
+        {
+            return base_awaiter.await_resume();
+        }
+    };
+    return AsyncIterAwaiter{AnyValueAwaiter{std::move(value)}, *this};
+}

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

@@ -32,6 +32,10 @@ namespace jspp
         {
             return AnyValue::make_promise((*func)(thisVal, args));
         }
+        else if (std::function<jspp::JsAsyncIterator<jspp::AnyValue>(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<3>(&callable))
+        {
+            return AnyValue::from_async_iterator((*func)(thisVal, args));
+        }
         else
         {
             return AnyValue::make_undefined();

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

@@ -92,6 +92,10 @@ namespace jspp {
         }
     }
 
+    inline auto JsPromise::operator co_await() const {
+        return AnyValueAwaiter{AnyValue::make_promise(*this)};
+    }
+
     inline std::string JsPromise::to_std_string() const {
         return "[object Promise]";
     }
@@ -144,17 +148,20 @@ namespace jspp {
          return AnyValueAwaiter{value};
     }
 
+    inline auto JsPromisePromiseType::await_transform(const JsPromise& value) {
+         return AnyValueAwaiter{AnyValue::make_promise(value)};
+    }
+
     // --- AnyValueAwaiter ---
 
     inline bool AnyValueAwaiter::await_ready() {
-        if (!value.is_promise()) return true; // Non-promise values are ready immediately (for now)
-        // Always suspend for promises to ensure microtask interleaving, even if already resolved.
+        // Always suspend to ensure microtask interleaving, even if already resolved or not a promise.
         return false;
     }
 
     inline void AnyValueAwaiter::await_suspend(std::coroutine_handle<> h) {
         if (!value.is_promise()) {
-            h.resume();
+            jspp::Scheduler::instance().enqueue([h]() mutable { h.resume(); });
             return;
         }
         auto p = value.as_promise();

package/src/prelude/values/promise.hpp

@@ -46,6 +46,8 @@ namespace jspp
         std::string to_std_string() const;
         AnyValue get_property(const std::string& key, const AnyValue& thisVal);
         AnyValue set_property(const std::string& key, const AnyValue& value, const AnyValue& thisVal);
+
+        auto operator co_await() const;
     };
 
     struct JsPromisePromiseType {
@@ -61,13 +63,7 @@ namespace jspp
         
         // await_transform for AnyValue
         auto await_transform(const AnyValue& value);
-    };
-    
-    // Awaiter for AnyValue
-    struct AnyValueAwaiter {
-        const AnyValue& value; // Reference to the value being awaited
-        bool await_ready();
-        void await_suspend(std::coroutine_handle<> h);
-        AnyValue await_resume();
+        // await_transform for JsPromise
+        auto await_transform(const JsPromise& value);
     };
 }

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

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/async_iterator.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp
+{
+    namespace AsyncIteratorPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsAsyncIterator<AnyValue> *self)
+        {
+            // --- toString() method ---
+            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+            // --- [Symbol.asyncIterator]() method ---
+            // For async iterators, the async iterator is itself (similar to sync iterators)
+            if (key == WellKnownSymbols::asyncIterator->key)
+            {
+                // We return 'this'. Since we can't easily create a shared_ptr from raw pointer,
+                // we rely on the context to hold the reference or implement better shared_from_this strategy.
+                // For now, assume it works like Iterator.
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                               { 
+                                                    // This is slightly dangerous as we create a new shared_ptr from raw.
+                                                    // TODO: fix lifetime management
+                                                    return thisVal; },
+                                               key);
+            }
+            // --- next() method ---
+            if (key == "next")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                               {
+                                                AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
+                                                auto res = self->next(val);
+                                                return AnyValue::make_promise(res); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}