@ugo-studio/jspp 0.1.4 → 0.1.5

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/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,85 @@
 #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
 
-    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;
     }
 }

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

@@ -1,125 +1,110 @@
 #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)
+    std::string JsFunction::to_std_string() const
     {
-        return "function* " + name + "() { [native code] }";
+        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] }";
     }
-    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))
+    AnyValue JsFunction::call(const AnyValue &thisVal, std::span<const AnyValue> args)
     {
-        return AnyValue::make_promise((*func)(thisVal, args));
-    }
-    else
-    {
-        return AnyValue::make_undefined();
-    }
-}
-
-jspp::AnyValue jspp::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 (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::resolve_property_for_write(proto_value, thisVal, value, key);
+            return AnyValue::make_promise((*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;
 }