@ugo-studio/jspp 0.1.3 → 0.1.4

package/src/prelude/utils/log_any_value/object.hpp

@@ -0,0 +1,119 @@
+#pragma once
+#include "types.hpp"
+#include "any_value.hpp"
+#include "library/error.hpp"
+#include "utils/log_any_value/config.hpp"
+#include "utils/log_any_value/helpers.hpp"
+#include "utils/log_any_value/fwd.hpp" // Required for recursive to_log_string call
+#include <string>
+#include <sstream>
+#include <unordered_set>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        inline std::string format_object(const AnyValue &val, std::unordered_set<const void *> &visited, int depth)
+        {
+            auto obj = val.as_object();
+
+            size_t prop_count = obj->props.size();
+            bool use_horizontal_layout = prop_count > 0 && prop_count <= HORIZONTAL_OBJECT_MAX_PROPS;
+
+            if (use_horizontal_layout)
+            {
+                for (const auto &pair : obj->props)
+                {
+                    if (!is_simple_value(pair.second))
+                    {
+                        use_horizontal_layout = false;
+                        break;
+                    }
+                }
+            }
+
+            std::string indent(depth * 2, ' ');
+            std::string next_indent((depth + 1) * 2, ' ');
+            std::stringstream ss;
+
+            // Special handling for Error objects
+            try
+            {
+                auto is_error = isErrorFn.as_function()->call(isErrorFn, {val}).is_truthy();
+                if (is_error)
+                {
+                    auto result = errorToStringFn.as_function()->call(val, {});
+                    if (result.is_string())
+                    {
+                        ss << result.to_std_string() << " ";
+                    }
+                }
+            }
+            catch (...)
+            {
+                // ignore
+            }
+
+            if (use_horizontal_layout)
+            {
+                ss << "{ ";
+                size_t current_prop = 0;
+                for (const auto &pair : obj->props)
+                {
+                    if (!is_enumerable_property(pair.second))
+                        continue;
+
+                    if (is_valid_js_identifier(pair.first))
+                    {
+                        ss << pair.first;
+                    }
+                    else
+                    {
+                        ss << "\"" << pair.first << "\"";
+                    }
+                    ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                    if (++current_prop < prop_count)
+                        ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                }
+                ss << " }";
+            }
+            else
+            {
+                ss << "{";
+                if (prop_count > 0)
+                {
+                    ss << "\n";
+                    size_t props_shown = 0;
+                    for (const auto &pair : obj->props)
+                    {
+                        if (props_shown >= MAX_OBJECT_PROPS)
+                            break;
+                        if (props_shown > 0)
+                            ss << ",\n";
+                        if (!is_enumerable_property(pair.second))
+                            continue;
+
+                        ss << next_indent;
+                        if (is_valid_js_identifier(pair.first))
+                        {
+                            ss << pair.first;
+                        }
+                        else
+                        {
+                            ss << "\"" << pair.first << "\"";
+                        }
+                        ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                        props_shown++;
+                    }
+                    if (prop_count > MAX_OBJECT_PROPS)
+                        ss << ",\n"
+                           << next_indent << Color::BRIGHT_BLACK << "... " << (prop_count - MAX_OBJECT_PROPS) << " more properties" << Color::RESET;
+                    ss << "\n"
+                       << indent;
+                }
+                ss << "}";
+            }
+            return ss.str();
+        }
+    }
+}

package/src/prelude/utils/log_any_value/primitives.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/log_any_value/config.hpp"
+#include "utils/log_any_value/helpers.hpp"
+#include <string>
+#include <optional>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        inline std::optional<std::string> format_primitive(const AnyValue &val, int depth)
+        {
+            if (val.is_uninitialized())
+                return Color::BRIGHT_BLACK + std::string("<uninitialized>") + Color::RESET;
+            if (val.is_undefined())
+                return Color::BRIGHT_BLACK + std::string("undefined") + Color::RESET;
+            if (val.is_null())
+                return Color::MAGENTA + std::string("null") + Color::RESET;
+            if (val.is_boolean())
+                return Color::YELLOW + std::string(val.as_boolean() ? "true" : "false") + Color::RESET;
+            if (val.is_number())
+                return Color::YELLOW + val.to_std_string() + Color::RESET;
+            if (val.is_symbol())
+                return Color::BLUE + val.to_std_string() + Color::RESET;
+            if (val.is_accessor_descriptor())
+                return Color::BLUE + std::string("[Getter/Setter]") + Color::RESET;
+
+            if (val.is_string())
+            {
+                const std::string &s = val.as_string()->value;
+                if (depth == 0)
+                    return truncate_string(s);
+                return Color::GREEN + std::string("\"") + truncate_string(s) + "\"" + Color::RESET;
+            }
+
+            return std::nullopt; // Not a primitive
+        }
+    }
+}

package/src/prelude/{operators.hpp → utils/operators.hpp}

@@ -13,15 +13,18 @@ namespace jspp
         // Implements the ToNumber abstract operation from ECMA-262.
         inline double ToNumber(const AnyValue &val)
         {
-            if (val.is_number())
+            switch (val.get_type())
+            {
+            case JsType::Number:
                 return val.as_double();
-            if (val.is_null())
+            case JsType::Null:
                 return 0.0;
-            if (val.is_undefined() || val.is_uninitialized())
+            case JsType::Uninitialized:
+            case JsType::Undefined:
                 return std::numeric_limits<double>::quiet_NaN();
-            if (val.is_boolean())
+            case JsType::Boolean:
                 return val.as_boolean() ? 1.0 : 0.0;
-            if (val.is_string())
+            case JsType::String:
             {
                 const std::string &s = val.as_string()->value;
                 // JS considers empty or whitespace-only strings as 0.
@@ -43,9 +46,11 @@ namespace jspp
                     return std::numeric_limits<double>::quiet_NaN();
                 }
             }
-            // In a full engine, objects would be converted via valueOf/toString.
-            // Here we simplify and return NaN.
-            return std::numeric_limits<double>::quiet_NaN();
+            default:
+                // In a full engine, objects would be converted via valueOf/toString.
+                // Here we simplify and return NaN.
+                return std::numeric_limits<double>::quiet_NaN();
+            }
         }
         // Implements the ToInt32 abstract operation from ECMA-262.
         inline int32_t ToInt32(const AnyValue &val)
@@ -144,11 +149,25 @@ namespace jspp
     }
     inline AnyValue operator==(const AnyValue &lhs, const AnyValue &rhs)
     {
-        return AnyValue::make_boolean(lhs.is_equal_to(rhs));
+        return AnyValue::make_boolean(lhs.is_equal_to_primitive(rhs));
     }
     inline AnyValue operator!=(const AnyValue &lhs, const AnyValue &rhs)
     {
-        return AnyValue::make_boolean(!lhs.is_equal_to(rhs));
+        return AnyValue::make_boolean(!lhs.is_equal_to_primitive(rhs));
+    }
+
+    // --- LOGICAL OPERATORS
+    inline AnyValue operator||(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        if (lhs.is_truthy())
+            return lhs;
+        return rhs;
+    }
+    inline AnyValue operator&&(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        if (!lhs.is_truthy())
+            return lhs;
+        return rhs;
     }
 
     // --- BITWISE OPERATORS

package/src/prelude/{well_known_symbols.hpp → utils/well_known_symbols.hpp}

@@ -9,6 +9,5 @@ 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> toString = std::make_shared<JsSymbol>("Symbol.toString", "@@toString");
     }
 }

package/src/prelude/values/array.hpp

@@ -17,13 +17,14 @@ namespace jspp
 
         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()) {}
 
         std::string to_std_string() const;
         JsIterator<AnyValue> get_iterator();
 
-        AnyValue get_property(const std::string &key);
+        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 &, 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
         bool enumerable = false;
         bool configurable = true;
     };

package/src/prelude/values/function.hpp

@@ -1,51 +1,76 @@
-#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> // Ensure variant is included
+
+namespace jspp
+{
+    // 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
+
+    struct JsFunction
+    {
+        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::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)
+        {
+        }
+
+        std::string to_std_string() const;
+        AnyValue call(const AnyValue &thisVal, const std::vector<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);
+    };
+}

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"
 
@@ -57,7 +57,7 @@ jspp::JsIterator<jspp::AnyValue> jspp::JsArray::get_iterator()
     co_return AnyValue::make_undefined();
 }
 
-jspp::AnyValue jspp::JsArray::get_property(const std::string &key)
+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.
@@ -75,12 +75,12 @@ jspp::AnyValue jspp::JsArray::get_property(const std::string &key)
             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 +88,17 @@ 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()));
+        return dense[idx].value_or(AnyValue::make_undefined());
     }
     const auto &it = sparse.find(idx);
     if (it != sparse.end())
     {
-        return AnyValue::resolve_property_for_read(it->second.value_or(AnyValue::make_undefined()));
+        return it->second.value_or(AnyValue::make_undefined());
     }
     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.
@@ -114,14 +114,21 @@ jspp::AnyValue jspp::JsArray::set_property(const std::string &key, const AnyValu
         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
         {
@@ -144,7 +151,8 @@ jspp::AnyValue jspp::JsArray::set_property(uint32_t idx, const AnyValue &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)
     {
@@ -161,7 +169,8 @@ jspp::AnyValue jspp::JsArray::set_property(uint32_t idx, const AnyValue &value)
             {
                 it->second = AnyValue::make_undefined();
             }
-            return AnyValue::resolve_property_for_write(it->second.value(), value);
+            it->second = value;
+            return value;
         }
         else
         {