@ugo-studio/jspp 0.1.2 → 0.1.4

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

@@ -0,0 +1,37 @@
+#pragma once
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/log_any_value/config.hpp"
+#include <string>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        inline std::string format_function(const AnyValue &val)
+        {
+            auto fn = val.as_function();
+
+            if (fn->is_class)
+            {
+                std::string extends_part = "";
+                if (fn->proto && !fn->proto->is_uninitialized() && !fn->proto->is_undefined() && !fn->proto->is_null())
+                {
+                    if (fn->proto->is_function())
+                    {
+                        auto parent = fn->proto->as_function();
+                        if (!parent->name.empty())
+                        {
+                            extends_part = " extends " + parent->name;
+                        }
+                    }
+                }
+                return Color::CYAN + std::string("[class ") + (fn->name.empty() ? "(anonymous)" : fn->name) + extends_part + "]" + Color::RESET;
+            }
+
+            auto type_part = fn->is_generator ? "GeneratorFunction" : "Function";
+            auto name_part = fn->name.size() > 0 ? ": " + fn->name : " (anonymous)";
+            return Color::CYAN + "[" + type_part + name_part + "]" + Color::RESET;
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+#include <unordered_set>
+#include "any_value.hpp"
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        // Forward declarations
+        inline std::string to_log_string(const AnyValue &val);
+        inline std::string to_log_string(const AnyValue &val, std::unordered_set<const void *> &visited, int depth);
+    }
+}

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

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/log_any_value/config.hpp"
+#include <string>
+#include <cctype>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        inline bool is_valid_js_identifier(const std::string &s)
+        {
+            if (s.empty())
+            {
+                return false;
+            }
+            if (!std::isalpha(s[0]) && s[0] != '_' && s[0] != '$')
+            {
+                return false;
+            }
+            for (size_t i = 1; i < s.length(); ++i)
+            {
+                if (!std::isalnum(s[i]) && s[i] != '_' && s[i] != '$')
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        inline bool is_simple_value(const AnyValue &val)
+        {
+            return val.is_undefined() || val.is_null() || val.is_uninitialized() ||
+                   val.is_boolean() || val.is_number() || val.is_string();
+        }
+
+        inline bool is_enumerable_property(const AnyValue &val)
+        {
+            if (val.is_data_descriptor())
+            {
+                return val.as_data_descriptor()->enumerable;
+            }
+            else if (
+                val.is_accessor_descriptor())
+            {
+                return val.as_accessor_descriptor()->enumerable;
+            }
+            return true;
+        }
+
+        inline std::string truncate_string(const std::string &str)
+        {
+            if (str.length() > MAX_STRING_LENGTH)
+            {
+                return str.substr(0, MAX_STRING_LENGTH) + "...";
+            }
+            return str;
+        }
+    }
+}

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

@@ -0,0 +1,94 @@
+#pragma once
+
+#include "types.hpp"
+#include "utils/well_known_symbols.hpp"
+#include "any_value.hpp"
+#include "utils/log_any_value/config.hpp"
+#include "utils/log_any_value/fwd.hpp"
+#include "utils/log_any_value/helpers.hpp"
+#include "utils/log_any_value/primitives.hpp"
+#include "utils/log_any_value/function.hpp"
+#include "utils/log_any_value/object.hpp"
+#include "utils/log_any_value/array.hpp"
+
+#include <unordered_set>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        inline std::string to_log_string(const AnyValue &val)
+        {
+            std::unordered_set<const void *> visited;
+            return to_log_string(val, visited, 0);
+        }
+
+        inline std::string to_log_string(const AnyValue &val, std::unordered_set<const void *> &visited, int depth)
+        {
+            // 1. Try Primitives
+            auto primitiveStr = format_primitive(val, depth);
+            if (primitiveStr.has_value())
+            {
+                return primitiveStr.value();
+            }
+
+            // 2. Functions
+            if (val.is_function())
+            {
+                return format_function(val);
+            }
+
+            // 3. Depth limit
+            if (depth > MAX_DEPTH)
+            {
+                if (val.is_object())
+                    return Color::CYAN + std::string("[Object]") + Color::RESET;
+                if (val.is_array())
+                    return Color::CYAN + std::string("[Array]") + Color::RESET;
+            }
+
+            // 4. Circular reference detection
+            const void *ptr_address = nullptr;
+            if (val.is_object())
+                ptr_address = val.as_object();
+            else if (val.is_array())
+                ptr_address = val.as_array();
+
+            if (ptr_address)
+            {
+                if (visited.count(ptr_address))
+                    return Color::CYAN + std::string("[Circular]") + Color::RESET;
+                visited.insert(ptr_address);
+            }
+
+            // 5. Complex Types (Objects & Arrays)
+            if (val.is_object())
+            {
+                return format_object(val, visited, depth);
+            }
+
+            if (val.is_array())
+            {
+                return format_array(val, visited, depth);
+            }
+
+            // 6. DataDescriptor
+            if (val.is_data_descriptor())
+            {
+                auto desc = val.as_data_descriptor();
+                if (desc->enumerable)
+                {
+                    return to_log_string((*desc->value), visited, depth);
+                }
+                else
+                {
+                    // Will not be printed if the method works well
+                    return Color::BRIGHT_BLACK + "<non-enumerable>" + Color::RESET;
+                }
+            }
+
+            // Fallback
+            return val.to_std_string();
+        }
+    }
+}

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,17 +13,20 @@ 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();
+                const std::string &s = val.as_string()->value;
                 // JS considers empty or whitespace-only strings as 0.
                 if (s.empty() || std::all_of(s.begin(), s.end(), isspace))
                     return 0.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)
@@ -116,7 +121,7 @@ namespace jspp
     {
         // Simplified Abstract Relational Comparison
         if (lhs.is_string() && rhs.is_string())
-            return AnyValue::make_boolean(*lhs.as_string() < *rhs.as_string());
+            return AnyValue::make_boolean(lhs.as_string()->value < rhs.as_string()->value);
 
         double l = Operators_Private::ToNumber(lhs);
         double r = Operators_Private::ToNumber(rhs);
@@ -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/utils/well_known_symbols.hpp

@@ -0,0 +1,13 @@
+#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");
+    }
+}

package/src/prelude/values/array.hpp

@@ -5,6 +5,7 @@
 
 namespace jspp
 {
+    // Forward declaration of AnyValue
     class AnyValue;
 
     struct JsArray
@@ -16,12 +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,19 +1,76 @@
-#pragma once
-
-#include "types.hpp"
-
-namespace jspp
-{
-    class AnyValue;
-
-    struct JsFunction
-    {
-        std::function<AnyValue(const std::vector<AnyValue> &)> call;
-        std::string name;
-        std::unordered_map<std::string, AnyValue> props;
-
-        std::string to_std_string() const;
-        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);
+    };
+}