@ugo-studio/jspp 0.1.4 → 0.1.6

package/src/prelude/utils/well_known_symbols.hpp

@@ -9,5 +9,17 @@ namespace jspp
     {
         // We use a specific prefix "@@" for well-known symbols to distinguish them from user symbols
         inline std::shared_ptr<JsSymbol> iterator = std::make_shared<JsSymbol>("Symbol.iterator", "@@iterator");
+        inline std::shared_ptr<JsSymbol> asyncIterator = std::make_shared<JsSymbol>("Symbol.asyncIterator", "@@asyncIterator");
+        inline std::shared_ptr<JsSymbol> hasInstance = std::make_shared<JsSymbol>("Symbol.hasInstance", "@@hasInstance");
+        inline std::shared_ptr<JsSymbol> isConcatSpreadable = std::make_shared<JsSymbol>("Symbol.isConcatSpreadable", "@@isConcatSpreadable");
+        inline std::shared_ptr<JsSymbol> match = std::make_shared<JsSymbol>("Symbol.match", "@@match");
+        inline std::shared_ptr<JsSymbol> matchAll = std::make_shared<JsSymbol>("Symbol.matchAll", "@@matchAll");
+        inline std::shared_ptr<JsSymbol> replace = std::make_shared<JsSymbol>("Symbol.replace", "@@replace");
+        inline std::shared_ptr<JsSymbol> search = std::make_shared<JsSymbol>("Symbol.search", "@@search");
+        inline std::shared_ptr<JsSymbol> species = std::make_shared<JsSymbol>("Symbol.species", "@@species");
+        inline std::shared_ptr<JsSymbol> split = std::make_shared<JsSymbol>("Symbol.split", "@@split");
+        inline std::shared_ptr<JsSymbol> toPrimitive = std::make_shared<JsSymbol>("Symbol.toPrimitive", "@@toPrimitive");
+        inline std::shared_ptr<JsSymbol> toStringTag = std::make_shared<JsSymbol>("Symbol.toStringTag", "@@toStringTag");
+        inline std::shared_ptr<JsSymbol> unscopables = std::make_shared<JsSymbol>("Symbol.unscopables", "@@unscopables");
     }
 }

package/src/prelude/values/array.hpp

@@ -10,18 +10,20 @@ namespace jspp
 
     struct JsArray
     {
-        std::vector<std::optional<AnyValue>> dense;                   // dense storage for small/contiguous indices
-        std::unordered_map<uint32_t, std::optional<AnyValue>> sparse; // sparse indices (very large indices)
-        std::unordered_map<std::string, AnyValue> props;              // non-index string properties
+        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::shared_ptr<AnyValue> proto;
         uint64_t length = 0;
 
-        JsArray() = default;
-        explicit JsArray(const std::vector<std::optional<AnyValue>> &items) : dense(items), length(items.size()) {}
-        explicit JsArray(std::vector<std::optional<AnyValue>> &&items) : dense(std::move(items)), length(dense.size()) {}
+        JsArray() : proto(nullptr) {}
+        explicit JsArray(const std::vector<AnyValue> &items) : dense(items), proto(nullptr), length(items.size()) {}
+        explicit JsArray(std::vector<AnyValue> &&items) : dense(std::move(items)), proto(nullptr), length(dense.size()) {}
 
         std::string to_std_string() const;
         JsIterator<AnyValue> get_iterator();
 
+        bool has_property(const std::string &key) const;
         AnyValue get_property(const std::string &key, const AnyValue &thisVal);
         AnyValue get_property(uint32_t idx);
         AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);

package/src/prelude/values/async_iterator.hpp

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "types.hpp"
+#include <coroutine>
+#include <optional>
+#include <queue>
+#include <iostream>
+#include <utility>
+#include <exception>
+#include "values/promise.hpp"
+#include "scheduler.hpp"
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    template <typename T>
+    class JsAsyncIterator
+    {
+    public:
+        struct promise_type
+        {
+            std::queue<std::pair<JsPromise, T>> pending_calls;
+            bool is_awaiting = false;
+            bool is_running = false;
+            T current_input;
+
+            JsAsyncIterator get_return_object()
+            {
+                return JsAsyncIterator{
+                    std::coroutine_handle<promise_type>::from_promise(*this)};
+            }
+
+            std::suspend_always initial_suspend() noexcept { return {}; }
+
+            std::suspend_always final_suspend() noexcept { return {}; }
+
+            // Declarations
+            template <typename From>
+            auto yield_value(From &&from);
+
+            template <typename From>
+            void return_value(From &&from);
+
+            void unhandled_exception();
+
+            void fail_all(const AnyValue &reason);
+
+            auto 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)) {}
+
+        JsAsyncIterator(const JsAsyncIterator &) = delete;
+        JsAsyncIterator &operator=(const JsAsyncIterator &) = delete;
+
+        ~JsAsyncIterator()
+        {
+            if (handle)
+                handle.destroy();
+        }
+
+        std::unordered_map<std::string, AnyValue> props;
+
+        std::string to_std_string() const;
+
+        JsPromise next(const T &val = T());
+
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+        AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
+
+        void resume_next();
+    };
+}

package/src/prelude/values/descriptors.hpp

@@ -17,8 +17,8 @@ namespace jspp
 
     struct AccessorDescriptor
     {
-        std::optional<std::function<AnyValue(const AnyValue &, const std::vector<AnyValue> &)>> get; // getter = function or undefined
-        std::optional<std::function<AnyValue(const AnyValue &, const std::vector<AnyValue> &)>> set; // setter = function or undefined
+        std::optional<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>> get; // getter = function or undefined
+        std::optional<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>> set; // setter = function or undefined
         bool enumerable = false;
         bool configurable = true;
     };

package/src/prelude/values/function.hpp

@@ -1,76 +1,86 @@
 #pragma once
 
 #include "types.hpp"
-#include <variant> // Ensure variant is included
+#include <variant>
+#include <optional>
 
 namespace jspp
 {
-    // Forward declaration of AnyValue
-    class AnyValue;
+  // Forward declaration of AnyValue
+  class AnyValue;
 
-    using JsFunctionCallable = std::variant<std::function<AnyValue(const AnyValue &, const std::vector<AnyValue> &)>,                                // 0: Normal
-                                            std::function<jspp::JsIterator<jspp::AnyValue>(const AnyValue &, const std::vector<jspp::AnyValue> &)>, // 1: Generator
-                                            std::function<jspp::JsPromise(const AnyValue &, const std::vector<jspp::AnyValue> &)>>;                  // 2: Async
+  using JsFunctionCallable = std::variant<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>,                               // 0: Normal
+                                          std::function<jspp::JsIterator<jspp::AnyValue>(const AnyValue &, std::span<const AnyValue>)>, // 1: Generator
+                                          std::function<jspp::JsPromise(const AnyValue &, std::span<const AnyValue>)>,                 // 2: Async
+                                          std::function<jspp::JsAsyncIterator<jspp::AnyValue>(const AnyValue &, std::span<const AnyValue>)>>; // 3: Async Generator
 
-    struct JsFunction
+  struct JsFunction
+  {
+    JsFunctionCallable callable;
+    std::optional<std::string> name;
+    std::unordered_map<std::string, AnyValue> props;
+    std::shared_ptr<AnyValue> proto = nullptr;
+    bool is_generator;
+    bool is_async;
+    bool is_class;
+    bool is_constructor;
+
+    // ---- Constructor A: infer flags ----
+    JsFunction(const JsFunctionCallable &c,
+               std::optional<std::string> n = std::nullopt,
+               std::unordered_map<std::string, AnyValue> p = {},
+               bool is_cls = false,
+               bool is_ctor = true)
+        : callable(c),
+          name(std::move(n)),
+          props(std::move(p)),
+          is_generator(callable.index() == 1),
+          is_async(callable.index() == 2),
+          is_class(is_cls),
+          is_constructor(is_ctor && !is_generator && !is_async) // Generators and asyncs are never constructors
     {
-        JsFunctionCallable callable;
-        std::string name;
-        std::unordered_map<std::string, AnyValue> props;
-        std::shared_ptr<AnyValue> proto = nullptr;
-        bool is_generator;
-        bool is_async;
-        bool is_class;
+    }
 
-        // ---- Constructor A: infer flags ----
-        JsFunction(const JsFunctionCallable &c,
-                   std::string n = {},
-                   std::unordered_map<std::string, AnyValue> p = {},
-                   bool is_cls = false)
-            : callable(c),
-              name(std::move(n)),
-              props(std::move(p)),
-              is_generator(callable.index() == 1),
-              is_async(callable.index() == 2),
-              is_class(is_cls)
-        {
-        }
+    // ---- Constructor B: explicit generator flag (backward compat) ----
+    JsFunction(const JsFunctionCallable &c,
+               bool is_gen,
+               std::optional<std::string> n = std::nullopt,
+               std::unordered_map<std::string, AnyValue> p = {},
+               bool is_cls = false,
+               bool is_ctor = true)
+        : callable(c),
+          name(std::move(n)),
+          props(std::move(p)),
+          is_generator(is_gen),
+          is_async(callable.index() == 2),
+          is_class(is_cls),
+          is_constructor(is_ctor && !is_gen && !is_async)
+    {
+    }
 
-        // ---- Constructor B: explicit generator flag (backward compat) ----
-        JsFunction(const JsFunctionCallable &c,
-                   bool is_gen,
-                   std::string n = {},
-                   std::unordered_map<std::string, AnyValue> p = {},
-                   bool is_cls = false)
-            : callable(c),
-              name(std::move(n)),
-              props(std::move(p)),
-              is_generator(is_gen),
-              is_async(callable.index() == 2),
-              is_class(is_cls)
-        {
-        }
-        
-         // ---- Constructor C: explicit async flag ----
-        JsFunction(const JsFunctionCallable &c,
-                   bool is_gen,
-                   bool is_async_func,
-                   std::string n = {},
-                   std::unordered_map<std::string, AnyValue> p = {},
-                   bool is_cls = false)
-            : callable(c),
-              name(std::move(n)),
-              props(std::move(p)),
-              is_generator(is_gen),
-              is_async(is_async_func),
-              is_class(is_cls)
-        {
-        }
+    // ---- Constructor C: explicit async flag ----
+    JsFunction(const JsFunctionCallable &c,
+               bool is_gen,
+               bool is_async_func,
+               std::optional<std::string> n = std::nullopt,
+               std::unordered_map<std::string, AnyValue> p = {},
+               bool is_cls = false,
+               bool is_ctor = true)
+        : callable(c),
+          name(std::move(n)),
+          props(std::move(p)),
+          is_generator(is_gen),
+          is_async(is_async_func),
+          is_class(is_cls),
+          is_constructor(is_ctor && !is_gen && !is_async_func)
+    {
+    }
 
-        std::string to_std_string() const;
-        AnyValue call(const AnyValue &thisVal, const std::vector<AnyValue> &args);
+    std::string to_std_string() const;
+    AnyValue call(const AnyValue &thisVal, std::span<const AnyValue> args);
 
-        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
-        AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
-    };
+    bool has_property(const std::string &key) const;
+    AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+    AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
+  };
 }

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

@@ -16,23 +16,23 @@ std::string jspp::JsArray::to_std_string() const
     std::string result = "";
     for (uint64_t i = 0; i < length; ++i)
     {
-        std::optional<AnyValue> itemVal;
+        const AnyValue *itemPtr = nullptr;
         if (i < dense.size())
         {
-            itemVal = dense[i];
+            itemPtr = &dense[i];
         }
         else
         {
             auto it = sparse.find(static_cast<uint32_t>(i));
             if (it != sparse.end())
             {
-                itemVal = it->second;
+                itemPtr = &it->second;
             }
         }
 
-        if (itemVal.has_value())
+        if (itemPtr && !itemPtr->is_uninitialized())
         {
-            const auto &item = itemVal.value();
+            const auto &item = *itemPtr;
             if (!item.is_undefined() && !item.is_null())
             {
                 result += item.to_std_string();
@@ -57,6 +57,32 @@ jspp::JsIterator<jspp::AnyValue> jspp::JsArray::get_iterator()
     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 (
@@ -71,7 +97,26 @@ jspp::AnyValue jspp::JsArray::get_property(const std::string &key, const AnyValu
         auto it = props.find(key);
         if (it == props.end())
         {
-            // check prototype
+            // 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())
             {
@@ -88,12 +133,14 @@ jspp::AnyValue jspp::JsArray::get_property(uint32_t idx)
 {
     if (idx < dense.size())
     {
-        return dense[idx].value_or(AnyValue::make_undefined());
+        const auto &val = dense[idx];
+        return val.is_uninitialized() ? AnyValue::make_undefined() : val;
     }
     const auto &it = sparse.find(idx);
     if (it != sparse.end())
     {
-        return it->second.value_or(AnyValue::make_undefined());
+        const auto &val = it->second;
+        return val.is_uninitialized() ? AnyValue::make_undefined() : val;
     }
     return AnyValue::make_undefined();
 }
@@ -111,6 +158,12 @@ jspp::AnyValue jspp::JsArray::set_property(const std::string &key, const AnyValu
     {
         // 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();
@@ -147,35 +200,18 @@ jspp::AnyValue jspp::JsArray::set_property(uint32_t idx, const AnyValue &value)
     const uint32_t DENSE_GROW_THRESHOLD = 1024;
     if (idx < dense.size())
     {
-        if (!dense[idx].has_value())
-        {
-            dense[idx] = AnyValue::make_undefined();
-        }
         dense[idx] = value;
         return value;
     }
     else if (idx <= dense.size() + DENSE_GROW_THRESHOLD)
     {
-        dense.resize(idx + 1);
+        dense.resize(idx + 1, AnyValue::make_uninitialized());
         dense[idx] = value;
         return value;
     }
     else
     {
-        auto it = sparse.find(idx);
-        if (it != sparse.end())
-        {
-            if (!it->second.has_value())
-            {
-                it->second = AnyValue::make_undefined();
-            }
-            it->second = value;
-            return value;
-        }
-        else
-        {
-            sparse[idx] = value;
-            return value;
-        }
+        sparse[idx] = value;
+        return value;
     }
 }