@ugo-studio/jspp 0.1.8 → 0.2.0

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

@@ -1,220 +1,209 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/array.hpp"
-#include "exception.hpp"
-#include "any_value.hpp"
-#include "values/prototypes/array.hpp"
-
-jspp::JsArray::JsArray(const std::vector<jspp::AnyValue> &items) : dense(items), proto(nullptr), length(items.size()) {}
-jspp::JsArray::JsArray(std::vector<jspp::AnyValue> &&items) : dense(std::move(items)), proto(nullptr), length(dense.size()) {}
-
-std::string jspp::JsArray::to_std_string() const
-{
-    if (length == 0)
-    {
-        return "";
-    }
-
-    std::string result = "";
-    for (uint64_t i = 0; i < length; ++i)
-    {
-        const AnyValue *itemPtr = nullptr;
-        if (i < dense.size())
-        {
-            itemPtr = &dense[i];
-        }
-        else
-        {
-            auto it = sparse.find(static_cast<uint32_t>(i));
-            if (it != sparse.end())
-            {
-                itemPtr = &it->second;
-            }
-        }
-
-        if (itemPtr && !itemPtr->is_uninitialized())
-        {
-            const auto &item = *itemPtr;
-            if (!item.is_undefined() && !item.is_null())
-            {
-                result += item.to_std_string();
-            }
-        }
-
-        if (i < length - 1)
-        {
-            result += ",";
-        }
-    }
-    return result;
-}
-
-jspp::JsIterator<jspp::AnyValue> jspp::JsArray::get_iterator()
-{
-    for (uint64_t idx = 0; idx < length; ++idx)
-    {
-        co_yield get_property(static_cast<uint32_t>(idx));
-    }
-
-    co_return AnyValue::make_undefined();
-}
-
-bool jspp::JsArray::has_property(const std::string &key) const
-{
-    if (key == "length")
-        return true;
-    if (is_array_index(key))
-    {
-        uint32_t idx = static_cast<uint32_t>(std::stoull(key));
-        if (idx < dense.size())
-            return true;
-        if (sparse.find(idx) != sparse.end())
-            return true;
-    }
-    if (props.find(key) != props.end())
-        return true;
-
-    if (proto && !(*proto).is_null() && !(*proto).is_undefined())
-    {
-        if ((*proto).has_property(key))
-            return true;
-    }
-
-    if (ArrayPrototypes::get(key, const_cast<JsArray *>(this)).has_value())
-        return true;
-    return false;
-}
-
-jspp::AnyValue jspp::JsArray::get_property(const std::string &key, const AnyValue &thisVal)
-{
-    if (
-        !key.empty() && std::isdigit(static_cast<unsigned char>(key[0])) // Quick check: if the first character is not a digit, it can't be a standard index.
-        && is_array_index(key))
-    {
-        uint32_t idx = static_cast<uint32_t>(std::stoull(key));
-        return get_property(idx);
-    }
-    else
-    {
-        auto it = props.find(key);
-        if (it == props.end())
-        {
-            // check special own properties (length)
-            if (key == "length")
-            {
-                auto proto_it = ArrayPrototypes::get(key, this);
-                if (proto_it.has_value())
-                {
-                    return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
-                }
-            }
-
-            // check explicit proto chain
-            if (proto && !(*proto).is_null() && !(*proto).is_undefined())
-            {
-                if ((*proto).has_property(key))
-                {
-                    return (*proto).get_property_with_receiver(key, thisVal);
-                }
-            }
-
-            // check prototype (implicit Array.prototype)
-            auto proto_it = ArrayPrototypes::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);
-    }
-}
-
-jspp::AnyValue jspp::JsArray::get_property(uint32_t idx)
-{
-    if (idx < dense.size())
-    {
-        const auto &val = dense[idx];
-        return val.is_uninitialized() ? AnyValue::make_undefined() : val;
-    }
-    const auto &it = sparse.find(idx);
-    if (it != sparse.end())
-    {
-        const auto &val = it->second;
-        return val.is_uninitialized() ? AnyValue::make_undefined() : val;
-    }
-    return AnyValue::make_undefined();
-}
-
-jspp::AnyValue jspp::JsArray::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
-{
-    if (
-        !key.empty() && std::isdigit(static_cast<unsigned char>(key[0])) // Quick check: if the first character is not a digit, it can't be a standard index.
-        && is_array_index(key))
-    {
-        uint32_t idx = static_cast<uint32_t>(std::stoull(key));
-        return set_property(idx, value);
-    }
-    else
-    {
-        // set prototype property if accessor descriptor
-        auto proto_val_opt = ArrayPrototypes::get(key, this);
-        if (!proto_val_opt.has_value() && proto && !(*proto).is_null() && !(*proto).is_undefined())
-        {
-            // This is a bit simplified, ideally we should call get_property on proto to check descriptors
-            // For now, let's assume if it's not in ArrayPrototypes, it might be in the explicit proto chain
-        }
-
-        if (proto_val_opt.has_value())
-        {
-            auto proto_value = proto_val_opt.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;
-        }
-    }
-}
-
-jspp::AnyValue jspp::JsArray::set_property(uint32_t idx, const AnyValue &value)
-{
-    uint64_t newLen = static_cast<uint64_t>(idx) + 1;
-    if (newLen > length)
-        length = newLen;
-
-    const uint32_t DENSE_GROW_THRESHOLD = 1024;
-    if (idx < dense.size())
-    {
-        dense[idx] = value;
-        return value;
-    }
-    else if (idx <= dense.size() + DENSE_GROW_THRESHOLD)
-    {
-        dense.resize(idx + 1, AnyValue::make_uninitialized());
-        dense[idx] = value;
-        return value;
-    }
-    else
-    {
-        sparse[idx] = value;
-        return value;
-    }
+#pragma once
+
+#include "types.hpp"
+#include "values/array.hpp"
+#include "exception.hpp"
+#include "any_value.hpp"
+#include "values/prototypes/array.hpp"
+
+inline jspp::JsArray::JsArray() : proto(Constants::Null), length(0) {}
+inline jspp::JsArray::JsArray(const std::vector<jspp::AnyValue> &items) : dense(items), proto(Constants::Null), length(items.size()) {}
+inline jspp::JsArray::JsArray(std::vector<jspp::AnyValue> &&items) : dense(std::move(items)), proto(Constants::Null), length(dense.size()) {}
+
+inline std::string jspp::JsArray::to_std_string() const
+{
+    if (length == 0)
+    {
+        return "";
+    }
+
+    std::string result = "";
+    for (uint64_t i = 0; i < length; ++i)
+    {
+        AnyValue itemVal = Constants::UNINITIALIZED;
+        if (i < dense.size())
+        {
+            itemVal = dense[i];
+        }
+        else
+        {
+            auto it = sparse.find(static_cast<uint32_t>(i));
+            if (it != sparse.end())
+            {
+                itemVal = it->second;
+            }
+        }
+
+        if (!itemVal.is_uninitialized())
+        {
+            if (!itemVal.is_undefined() && !itemVal.is_null())
+            {
+                result += itemVal.to_std_string();
+            }
+        }
+
+        if (i < length - 1)
+        {
+            result += ",";
+        }
+    }
+    return result;
+}
+
+inline jspp::JsIterator<jspp::AnyValue> jspp::JsArray::get_iterator()
+{
+    for (uint64_t idx = 0; idx < length; ++idx)
+    {
+        co_yield get_property(static_cast<uint32_t>(idx));
+    }
+
+    co_return AnyValue::make_undefined();
+}
+
+inline bool jspp::JsArray::has_property(const std::string &key) const
+{
+    if (key == "length")
+        return true;
+    if (is_array_index(key))
+    {
+        uint32_t idx = static_cast<uint32_t>(std::stoull(key));
+        if (idx < dense.size())
+            return true;
+        if (sparse.find(idx) != sparse.end())
+            return true;
+    }
+    if (props.find(key) != props.end())
+        return true;
+
+    if (!proto.is_null() && !proto.is_undefined())
+    {
+        if (proto.has_property(key))
+            return true;
+    }
+
+    if (ArrayPrototypes::get(key, const_cast<JsArray *>(this)).has_value())
+        return true;
+    return false;
+}
+
+inline jspp::AnyValue jspp::JsArray::get_property(const std::string &key, const AnyValue &thisVal)
+{
+    if (
+        !key.empty() && std::isdigit(static_cast<unsigned char>(key[0])) 
+        && is_array_index(key))
+    {
+        uint32_t idx = static_cast<uint32_t>(std::stoull(key));
+        return get_property(idx);
+    }
+    else
+    {
+        auto it = props.find(key);
+        if (it == props.end())
+        {
+            if (key == "length")
+            {
+                auto proto_it = ArrayPrototypes::get(key, this);
+                if (proto_it.has_value())
+                {
+                    return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+                }
+            }
+
+            if (!proto.is_null() && !proto.is_undefined())
+            {
+                if (proto.has_property(key))
+                {
+                    return proto.get_property_with_receiver(key, thisVal);
+                }
+            }
+
+            auto proto_it = ArrayPrototypes::get(key, this);
+            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 jspp::AnyValue jspp::JsArray::get_property(uint32_t idx)
+{
+    if (idx < dense.size())
+    {
+        const auto &val = dense[idx];
+        return val.is_uninitialized() ? Constants::UNDEFINED : val;
+    }
+    const auto &it = sparse.find(idx);
+    if (it != sparse.end())
+    {
+        const auto &val = it->second;
+        return val.is_uninitialized() ? Constants::UNDEFINED : val;
+    }
+    return Constants::UNDEFINED;
+}
+
+inline jspp::AnyValue jspp::JsArray::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+{
+    if (
+        !key.empty() && std::isdigit(static_cast<unsigned char>(key[0])) 
+        && is_array_index(key))
+    {
+        uint32_t idx = static_cast<uint32_t>(std::stoull(key));
+        return set_property(idx, value);
+    }
+    else
+    {
+        auto proto_val_opt = ArrayPrototypes::get(key, this);
+        
+        if (proto_val_opt.has_value())
+        {
+            auto proto_value = proto_val_opt.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;
+        }
+    }
+}
+
+inline jspp::AnyValue jspp::JsArray::set_property(uint32_t idx, const AnyValue &value)
+{
+    uint64_t newLen = static_cast<uint64_t>(idx) + 1;
+    if (newLen > length)
+        length = newLen;
+
+    const uint32_t DENSE_GROW_THRESHOLD = 1024;
+    if (idx < dense.size())
+    {
+        dense[idx] = value;
+        return value;
+    }
+    else if (idx <= dense.size() + DENSE_GROW_THRESHOLD)
+    {
+        dense.resize(idx + 1, Constants::UNINITIALIZED);
+        dense[idx] = value;
+        return value;
+    }
+    else
+    {
+        sparse[idx] = value;
+        return value;
+    }
 }

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

@@ -27,7 +27,7 @@ jspp::AnyValue jspp::JsAsyncIterator<T>::get_property(const std::string &key, co
                 return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
             }
         }
-        return AnyValue::make_undefined();
+        return Constants::UNDEFINED;
     }
     return AnyValue::resolve_property_for_read(it->second, thisVal, key);
 }
@@ -95,6 +95,9 @@ void jspp::JsAsyncIterator<T>::resume_next()
 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)
     {
@@ -125,7 +128,7 @@ auto jspp::JsAsyncIterator<T>::promise_type::yield_value(From &&from)
     {
         auto call = pending_calls.front();
         pending_calls.pop();
-        AnyValue result = AnyValue::make_object({{"value", std::forward<From>(from)}, {"done", AnyValue::make_boolean(false)}});
+        AnyValue result = AnyValue::make_object({{"value", std::forward<From>(from)}, {"done", Constants::FALSE}});
         call.first.resolve(result);
     }
 
@@ -183,7 +186,7 @@ void jspp::JsAsyncIterator<T>::promise_type::unhandled_exception()
     }
     catch (const Exception &e)
     {
-        fail_all(*e.data);
+        fail_all(e.data);
     }
     catch (const std::exception &e)
     {
@@ -239,14 +242,8 @@ auto jspp::JsAsyncIterator<T>::promise_type::await_transform(AnyValue value)
                     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;
@@ -263,7 +260,6 @@ auto jspp::JsAsyncIterator<T>::promise_type::await_transform(AnyValue value)
                     pr.is_running = true;
                     h.resume();
                     pr.is_running = false;
-                    // Errors handled via await_resume/exception throw
                 });
         }
         AnyValue await_resume()
@@ -272,4 +268,4 @@ auto jspp::JsAsyncIterator<T>::promise_type::await_transform(AnyValue value)
         }
     };
     return AsyncIterAwaiter{AnyValueAwaiter{std::move(value)}, *this};
-}
+}

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

@@ -10,7 +10,7 @@
 
 namespace jspp
 {
-    std::string JsFunction::to_std_string() const
+    inline std::string JsFunction::to_std_string() const
     {
         std::string type_part = this->is_async ? "async function" : this->is_generator ? "function*"
                                                                                        : "function";
@@ -18,7 +18,7 @@ namespace jspp
         return type_part + " " + name_part + "() { [native code] }";
     }
 
-    AnyValue JsFunction::call(const AnyValue &thisVal, std::span<const AnyValue> args)
+    inline AnyValue JsFunction::call(const AnyValue &thisVal, std::span<const AnyValue> args)
     {
         if (std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<0>(&callable))
         {
@@ -38,17 +38,17 @@ namespace jspp
         }
         else
         {
-            return AnyValue::make_undefined();
+            return Constants::UNDEFINED;
         }
     }
 
-    bool JsFunction::has_property(const std::string &key) const
+    inline bool JsFunction::has_property(const std::string &key) const
     {
         if (props.find(key) != props.end())
             return true;
-        if (proto && !(*proto).is_null() && !(*proto).is_undefined())
+        if (!proto.is_null() && !proto.is_undefined())
         {
-            if ((*proto).has_property(key))
+            if (proto.has_property(key))
                 return true;
         }
         if (FunctionPrototypes::get(key, const_cast<JsFunction *>(this)).has_value())
@@ -56,35 +56,31 @@ namespace jspp
         return false;
     }
 
-    AnyValue JsFunction::get_property(const std::string &key, const AnyValue &thisVal)
+    inline AnyValue JsFunction::get_property(const std::string &key, const AnyValue &thisVal)
     {
         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.is_null() && !proto.is_undefined())
             {
-                if ((*proto).has_property(key))
+                if (proto.has_property(key))
                 {
-                    return (*proto).get_property_with_receiver(key, thisVal);
+                    return proto.get_property_with_receiver(key, thisVal);
                 }
             }
 
-            // 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 Constants::UNDEFINED;
         }
         return AnyValue::resolve_property_for_read(it->second, thisVal, key);
     }
 
-    AnyValue JsFunction::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+    inline AnyValue 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())
         {
@@ -99,7 +95,6 @@ namespace jspp
             }
         }
 
-        // set own property
         auto it = props.find(key);
         if (it != props.end())
         {