@ugo-studio/jspp 0.1.4 → 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

@@ -1,125 +1,114 @@
 #pragma once
 
 #include <variant>
+#include <optional>
 
 #include "types.hpp"
 #include "values/function.hpp"
 #include "any_value.hpp"
 #include "values/prototypes/function.hpp"
 
-std::string jspp::JsFunction::to_std_string() const
+namespace jspp
 {
-    if (is_async) {
-        return "async function " + name + "() { [native code] }";
-    }
-    if (is_generator)
-    {
-        return "function* " + name + "() { [native code] }";
-    }
-    return "function " + name + "() { [native code] }";
-}
-
-jspp::AnyValue jspp::JsFunction::call(const AnyValue &thisVal, const std::vector<AnyValue> &args)
-{
-    if (std::function<AnyValue(const AnyValue &, const std::vector<AnyValue> &)> *func = std::get_if<0>(&callable))
-    {
-        return (*func)(thisVal, args);
-    }
-    else if (std::function<jspp::JsIterator<jspp::AnyValue>(const AnyValue &, const std::vector<jspp::AnyValue> &)> *func = std::get_if<1>(&callable))
-    {
-        return AnyValue::from_iterator((*func)(thisVal, args));
-    }
-    else if (std::function<jspp::JsPromise(const AnyValue &, const std::vector<jspp::AnyValue> &)> *func = std::get_if<2>(&callable))
-    {
-        return AnyValue::make_promise((*func)(thisVal, args));
-    }
-    else
+    std::string JsFunction::to_std_string() const
     {
-        return AnyValue::make_undefined();
+        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] }";
     }
-}
 
-jspp::AnyValue jspp::JsFunction::get_property(const std::string &key, const AnyValue &thisVal)
-{
-    auto it = props.find(key);
-    if (it == props.end())
+    AnyValue JsFunction::call(const AnyValue &thisVal, std::span<const AnyValue> args)
     {
-        // check explicit proto chain (e.g. for classes extending other classes)
-        if (proto && !(*proto).is_null() && !(*proto).is_undefined())
+        if (std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<0>(&callable))
         {
-            return (*proto).get_property_with_receiver(key, thisVal);
+            return (*func)(thisVal, args);
         }
-
-        // check prototype (implicit Function.prototype)
-        auto proto_it = FunctionPrototypes::get(key, this);
-        if (proto_it.has_value())
+        else if (std::function<jspp::JsIterator<jspp::AnyValue>(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<1>(&callable))
         {
-            return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+            return AnyValue::from_iterator((*func)(thisVal, args));
         }
-        // not found
-        return AnyValue::make_undefined();
-    }
-    return AnyValue::resolve_property_for_read(it->second, thisVal, key);
-}
-
-jspp::AnyValue jspp::JsFunction::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
-{
-    // set prototype property if accessor descriptor
-    auto proto_it = FunctionPrototypes::get(key, this);
-    if (proto_it.has_value())
-    {
-        auto proto_value = proto_it.value();
-        if (proto_value.is_accessor_descriptor())
+        else if (std::function<jspp::JsPromise(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<2>(&callable))
+        {
+            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::resolve_property_for_write(proto_value, thisVal, value, key);
+            return AnyValue::from_async_iterator((*func)(thisVal, args));
         }
-        if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable)
+        else
         {
-            return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+            return AnyValue::make_undefined();
         }
     }
 
-    // set own property
-    auto it = props.find(key);
-    if (it != props.end())
+    bool JsFunction::has_property(const std::string &key) const
     {
-        return AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
-    }
-    else
-    {
-        props[key] = value;
-        return value;
+        if (props.find(key) != props.end())
+            return true;
+        if (proto && !(*proto).is_null() && !(*proto).is_undefined())
+        {
+            if ((*proto).has_property(key))
+                return true;
+        }
+        if (FunctionPrototypes::get(key, const_cast<JsFunction *>(this)).has_value())
+            return true;
+        return false;
     }
-}
 
-// AnyValue::construct implementation
-const jspp::AnyValue jspp::AnyValue::construct(const std::vector<AnyValue> &args) const
-{
-    if (!is_function())
+    AnyValue JsFunction::get_property(const std::string &key, const AnyValue &thisVal)
     {
-        throw Exception::make_exception(to_std_string() + " is not a constructor", "TypeError");
-    }
+        auto it = props.find(key);
+        if (it == props.end())
+        {
+            // check explicit proto chain (e.g. for classes extending other classes)
+            if (proto && !(*proto).is_null() && !(*proto).is_undefined())
+            {
+                if ((*proto).has_property(key))
+                {
+                    return (*proto).get_property_with_receiver(key, thisVal);
+                }
+            }
 
-    // 1. Get prototype
-    AnyValue proto = get_own_property("prototype");
-    // If prototype is not an object, default to a plain object (which ideally inherits from Object.prototype)
-    // Here we just make a plain object.
-    if (!proto.is_object())
-    {
-        proto = AnyValue::make_object({});
+            // check prototype (implicit Function.prototype)
+            auto proto_it = FunctionPrototypes::get(key, this);
+            if (proto_it.has_value())
+            {
+                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+            }
+            // not found
+            return AnyValue::make_undefined();
+        }
+        return AnyValue::resolve_property_for_read(it->second, thisVal, key);
     }
 
-    // 2. Create instance
-    AnyValue instance = AnyValue::make_object_with_proto({}, proto);
-
-    // 3. Call function
-    // We pass 'instance' as 'this'
-    AnyValue result = as_function()->call(instance, args);
-
-    // 4. Return result if object, else instance
-    if (result.is_object() || result.is_function() || result.is_array() || result.is_promise())
+    AnyValue JsFunction::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
     {
-        return result;
+        // set prototype property if accessor descriptor
+        auto proto_it = FunctionPrototypes::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);
+            }
+        }
+
+        // set own property
+        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;
+        }
     }
-    return instance;
-}
+}

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

@@ -35,9 +35,9 @@ jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::next(const T &val)
 }
 
 template <typename T>
-std::vector<std::optional<T>> jspp::JsIterator<T>::to_vector()
+std::vector<T> jspp::JsIterator<T>::to_vector()
 {
-    std::vector<std::optional<AnyValue>> result;
+    std::vector<T> result;
     while (true)
     {
         auto next = this->next();
@@ -45,7 +45,7 @@ std::vector<std::optional<T>> jspp::JsIterator<T>::to_vector()
         {
             break;
         }
-        result.push_back(next.value);
+        result.push_back(next.value.value_or(AnyValue::make_undefined()));
     }
     return result;
 }

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

@@ -4,24 +4,66 @@
 #include "values/object.hpp"
 #include "any_value.hpp"
 
+namespace jspp {
+    JsObject::JsObject() : shape(Shape::empty_shape()), proto(nullptr) {}
+
+    JsObject::JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, std::shared_ptr<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);
+        }
+    }
+
+    JsObject::JsObject(const std::map<std::string, AnyValue> &p, std::shared_ptr<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);
+        }
+    }
+}
+
 std::string jspp::JsObject::to_std_string() const
 {
     return "[Object Object]";
 }
 
+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 && !(*proto).is_null() && !(*proto).is_undefined())
+    {
+        if ((*proto).has_property(key))
+            return true;
+    }
+    if (ObjectPrototypes::get(key, const_cast<JsObject *>(this)).has_value())
+        return true;
+    return false;
+}
+
 jspp::AnyValue jspp::JsObject::get_property(const std::string &key, const AnyValue &thisVal)
 {
-    auto it = props.find(key);
-    if (it == props.end())
+    if (deleted_keys.count(key)) return AnyValue::make_undefined();
+
+    auto offset = shape->get_offset(key);
+    if (!offset.has_value())
     {
         // check prototype chain
         if (proto && !(*proto).is_null() && !(*proto).is_undefined())
         {
-            return (*proto).get_property_with_receiver(key, thisVal);
+            if ((*proto).has_property(key))
+            {
+                return (*proto).get_property_with_receiver(key, thisVal);
+            }
         }
 
         // check built-in prototype methods (Object.prototype)
-        // ideally these should be on the root prototype object, but for now we keep this fallback
         auto proto_it = ObjectPrototypes::get(key, this);
         if (proto_it.has_value())
         {
@@ -30,7 +72,7 @@ jspp::AnyValue jspp::JsObject::get_property(const std::string &key, const AnyVal
         // not found
         return AnyValue::make_undefined();
     }
-    return AnyValue::resolve_property_for_read(it->second, thisVal, key);
+    return AnyValue::resolve_property_for_read(storage[offset.value()], thisVal, key);
 }
 
 jspp::AnyValue jspp::JsObject::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
@@ -51,14 +93,17 @@ jspp::AnyValue jspp::JsObject::set_property(const std::string &key, const AnyVal
     }
 
     // set own property
-    auto it = props.find(key);
-    if (it != props.end())
+    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(it->second, thisVal, value, key);
+        return AnyValue::resolve_property_for_write(storage[offset.value()], thisVal, value, key);
     }
     else
     {
-        props[key] = value;
+        shape = shape->transition(key);
+        storage.push_back(value);
         return value;
     }
 }

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

@@ -24,13 +24,13 @@ namespace jspp {
              auto weak_state = std::weak_ptr<PromiseState>(state);
              
              p->then(
-                 [weak_state](AnyValue v) {
+                 [weak_state](const AnyValue& v) {
                      if (auto s = weak_state.lock()) {
                          JsPromise localP; localP.state = s;
                          localP.resolve(v); 
                      }
                  },
-                 [weak_state](AnyValue r) {
+                 [weak_state](const AnyValue& r) {
                      if (auto s = weak_state.lock()) {
                          JsPromise localP; localP.state = s;
                          localP.reject(r);
@@ -71,7 +71,7 @@ namespace jspp {
         }
     }
 
-    inline void JsPromise::then(std::function<void(AnyValue)> onFulfilled, std::function<void(AnyValue)> onRejected) {
+    inline void JsPromise::then(std::function<void(const AnyValue&)> onFulfilled, std::function<void(const AnyValue&)> onRejected) {
         if (state->status == PromiseStatus::Fulfilled) {
             if (onFulfilled) {
                 AnyValue val = *(state->result);
@@ -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/iterator.hpp

@@ -89,7 +89,7 @@ namespace jspp
 
         std::string to_std_string() const;
         NextResult next(const T &val = T());
-        std::vector<std::optional<T>> to_vector();
+        std::vector<T> to_vector();
         AnyValue get_property(const std::string &key, const AnyValue &thisVal);
         AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
     };