@ugo-studio/jspp 0.1.3 → 0.1.5

package/src/prelude/utils/well_known_symbols.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "values/symbol.hpp"
+#include <memory>
+
+namespace jspp
+{
+    namespace WellKnownSymbols
+    {
+        // 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,20 +10,23 @@ 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()) {}
+        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();
 
-        AnyValue get_property(const std::string &key);
+        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);
+        AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
         AnyValue set_property(uint32_t idx, const AnyValue &value);
 
         static bool is_array_index(const std::string &s)

package/src/prelude/{descriptors.hpp → values/descriptors.hpp}

@@ -17,8 +17,8 @@ namespace jspp
 
     struct AccessorDescriptor
     {
-        std::optional<std::function<AnyValue(const std::vector<AnyValue> &)>> get; // getter = function or undefined
-        std::optional<std::function<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,51 +1,85 @@
-#pragma once
-
-#include "types.hpp"
-
-namespace jspp
-{
-    // Forward declaration of AnyValue
-    class AnyValue;
-
-    using JsFunctionCallable = std::variant<std::function<AnyValue(const std::vector<AnyValue> &)>,                                // 0: Normal
-                                            std::function<jspp::JsIterator<jspp::AnyValue>(const std::vector<jspp::AnyValue> &)>>; // 1: Generator
-
-    struct JsFunction
-    {
-        JsFunctionCallable callable;
-        std::string name;
-        std::unordered_map<std::string, AnyValue> props;
-        bool is_generator;
-
-        // ---- Constructor A: infer is_generator using index() ----
-        JsFunction(const JsFunctionCallable &c,
-                   std::string n = {},
-                   std::unordered_map<std::string, AnyValue> p = {})
-            : callable(c),
-              name(std::move(n)),
-              props(std::move(p)),
-              is_generator(callable.index() == 1) // 1 = generator
-        {
-        }
-
-        // ---- Constructor B: explicitly set is_generator ----
-        JsFunction(const JsFunctionCallable &c,
-                   bool is_gen,
-                   std::string n = {},
-                   std::unordered_map<std::string, AnyValue> p = {})
-            : callable(c),
-              name(std::move(n)),
-              props(std::move(p)),
-              is_generator(is_gen)
-        {
-            // Optional debug check (no RTTI, no variant visitation):
-            // if (callable.index() == 1 && !is_gen) { ... }
-            // if (callable.index() == 0 && is_gen) { ... }
-        }
-
-        std::string to_std_string() const;
-        AnyValue call(const std::vector<AnyValue> &args);
-        AnyValue get_property(const std::string &key);
-        AnyValue set_property(const std::string &key, const AnyValue &value);
-    };
-}
+#pragma once
+
+#include "types.hpp"
+#include <variant>
+#include <optional>
+
+namespace jspp
+{
+  // Forward declaration of AnyValue
+  class AnyValue;
+
+  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
+  {
+    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
+    {
+    }
+
+    // ---- 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 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, std::span<const AnyValue> args);
+
+    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

@@ -2,7 +2,7 @@
 
 #include "types.hpp"
 #include "values/array.hpp"
-#include "error.hpp"
+#include "exception.hpp"
 #include "any_value.hpp"
 #include "values/prototypes/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,7 +57,33 @@ jspp::JsIterator<jspp::AnyValue> jspp::JsArray::get_iterator()
     co_return AnyValue::make_undefined();
 }
 
-jspp::AnyValue jspp::JsArray::get_property(const std::string &key)
+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.
@@ -71,16 +97,35 @@ jspp::AnyValue jspp::JsArray::get_property(const std::string &key)
         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())
             {
-                return AnyValue::resolve_property_for_read(proto_it.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);
+        return AnyValue::resolve_property_for_read(it->second, thisVal, key);
     }
 }
 
@@ -88,17 +133,19 @@ jspp::AnyValue jspp::JsArray::get_property(uint32_t idx)
 {
     if (idx < dense.size())
     {
-        return AnyValue::resolve_property_for_read(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 AnyValue::resolve_property_for_read(it->second.value_or(AnyValue::make_undefined()));
+        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)
+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.
@@ -111,17 +158,30 @@ 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();
-            return AnyValue::resolve_property_for_write(proto_value, 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, value);
+            return AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
         }
         else
         {
@@ -140,33 +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();
-        }
-        return AnyValue::resolve_property_for_write(dense[idx].value(), value);
+        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();
-            }
-            return AnyValue::resolve_property_for_write(it->second.value(), value);
-        }
-        else
-        {
-            sparse[idx] = value;
-            return value;
-        }
+        sparse[idx] = value;
+        return value;
     }
 }

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

@@ -1,77 +1,110 @@
-#pragma once
-
-#include <variant>
-
-#include "types.hpp"
-#include "values/function.hpp"
-#include "any_value.hpp"
-#include "values/prototypes/function.hpp"
-
-std::string jspp::JsFunction::to_std_string() const
-{
-    if (is_generator)
-    {
-        return "function* " + name + "() { [native code] }";
-    }
-    return "function " + name + "() { [native code] }";
-}
-
-jspp::AnyValue jspp::JsFunction::call(const std::vector<AnyValue> &args)
-{
-
-    if (std::function<AnyValue(const std::vector<AnyValue> &)> *func = std::get_if<0>(&callable))
-    {
-        return (*func)(args);
-    }
-    else if (std::function<jspp::JsIterator<jspp::AnyValue>(const std::vector<jspp::AnyValue> &)> *func = std::get_if<1>(&callable))
-    {
-        return AnyValue::from_iterator((*func)(args));
-    }
-    else
-    {
-        return AnyValue::make_undefined();
-    }
-}
-
-jspp::AnyValue jspp::JsFunction::get_property(const std::string &key)
-{
-    auto it = props.find(key);
-    if (it == props.end())
-    {
-        // check prototype
-        auto proto_it = FunctionPrototypes::get(key, this);
-        if (proto_it.has_value())
-        {
-            return AnyValue::resolve_property_for_read(proto_it.value());
-        }
-        // not found
-        return AnyValue::make_undefined();
-    }
-    return AnyValue::resolve_property_for_read(it->second);
-}
-
-jspp::AnyValue jspp::JsFunction::set_property(const std::string &key, const AnyValue &value)
-{
-    // 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, value);
-        }
-    }
-
-    // set own property
-    auto it = props.find(key);
-    if (it != props.end())
-    {
-        return AnyValue::resolve_property_for_write(it->second, value);
-    }
-    else
-    {
-        props[key] = value;
-        return value;
-    }
-}
+#pragma once
+
+#include <variant>
+#include <optional>
+
+#include "types.hpp"
+#include "values/function.hpp"
+#include "any_value.hpp"
+#include "values/prototypes/function.hpp"
+
+namespace jspp
+{
+    std::string JsFunction::to_std_string() const
+    {
+        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] }";
+    }
+
+    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))
+        {
+            return (*func)(thisVal, args);
+        }
+        else if (std::function<jspp::JsIterator<jspp::AnyValue>(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<1>(&callable))
+        {
+            return AnyValue::from_iterator((*func)(thisVal, args));
+        }
+        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
+        {
+            return AnyValue::make_undefined();
+        }
+    }
+
+    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).has_property(key))
+                return true;
+        }
+        if (FunctionPrototypes::get(key, const_cast<JsFunction *>(this)).has_value())
+            return true;
+        return false;
+    }
+
+    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).has_property(key))
+                {
+                    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 AnyValue::resolve_property_for_read(it->second, thisVal, key);
+    }
+
+    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())
+        {
+            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;
+        }
+    }
+}