@ugo-studio/jspp 0.1.3 → 0.1.5

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

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <string>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        // --- Configuration for Logging Verbosity ---
+        const int MAX_DEPTH = 5;
+        const size_t MAX_STRING_LENGTH = 100;
+        const size_t MAX_ARRAY_ITEMS = 50;
+        const size_t MAX_OBJECT_PROPS = 30;
+
+        // --- Configuration for Horizontal Layout ---
+        const size_t HORIZONTAL_ARRAY_MAX_ITEMS = 10;
+        const size_t HORIZONTAL_OBJECT_MAX_PROPS = 5;
+
+        // ANSI Color Codes for terminal output
+        namespace Color
+        {
+            const std::string RESET = "\033[0m";
+            const std::string RED = "\033[31m";
+            const std::string GREEN = "\033[32m";
+            const std::string YELLOW = "\033[33m";
+            const std::string BLUE = "\033[94m";
+            const std::string CYAN = "\033[36m";
+            const std::string MAGENTA = "\033[35m";
+            const std::string BRIGHT_BLACK = "\033[90m"; // Grey
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+#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();
+                        std::string name = parent->name.value_or("");
+                        if (!name.empty())
+                        {
+                            extends_part = " extends " + name;
+                        }
+                    }
+                }
+                std::string name = fn->name.value_or("");
+                return Color::CYAN + std::string("[class ") + (name.empty() ? "(anonymous)" : name) + extends_part + "]" + Color::RESET;
+            }
+
+            auto type_part = fn->is_generator ? "GeneratorFunction" : "Function";
+            auto name_part = fn->name.has_value() ? ": " + fn->name.value() : " (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,136 @@
+#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->storage.size();
+            bool use_horizontal_layout = prop_count > 0 && prop_count <= HORIZONTAL_OBJECT_MAX_PROPS;
+
+            for (size_t i = 0; i < obj->storage.size(); ++i)
+            {
+                const auto& prop_val = obj->storage[i];
+                if (!is_enumerable_property(prop_val))
+                {
+                    prop_count--;
+                    continue;
+                }
+                if (use_horizontal_layout && !is_simple_value(prop_val))
+                {
+                    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
+            {
+                const AnyValue args[] = {val};
+                auto is_error = is_truthy(isErrorFn.call(isErrorFn, std::span<const AnyValue>(args, 1)));
+                if (is_error)
+                {
+                    auto result = errorToStringFn.call(val, std::span<const AnyValue>{});
+                    if (result.is_string())
+                    {
+                        ss << result.to_std_string();
+                        if (prop_count == 0)
+                        {
+                            return ss.str();
+                        }
+                        ss << " ";
+                    }
+                }
+            }
+            catch (...)
+            {
+                // ignore
+            }
+
+            if (use_horizontal_layout)
+            {
+                ss << "{ ";
+                size_t current_prop = 0;
+                for (size_t i = 0; i < obj->shape->property_names.size(); ++i)
+                {
+                    const auto& key = obj->shape->property_names[i];
+                    const auto& prop_val = obj->storage[i];
+
+                    if (!is_enumerable_property(prop_val))
+                        continue;
+
+                    if (is_valid_js_identifier(key))
+                    {
+                        ss << key;
+                    }
+                    else
+                    {
+                        ss << "\"" << key << "\"";
+                    }
+                    ss << ": " << to_log_string(prop_val, 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 (size_t i = 0; i < obj->shape->property_names.size(); ++i)
+                    {
+                        const auto& key = obj->shape->property_names[i];
+                        const auto& prop_val = obj->storage[i];
+
+                        if (props_shown >= MAX_OBJECT_PROPS)
+                            break;
+                        
+                        if (!is_enumerable_property(prop_val))
+                            continue;
+
+                        if (props_shown > 0)
+                            ss << ",\n";
+
+                        ss << next_indent;
+                        if (is_valid_js_identifier(key))
+                        {
+                            ss << key;
+                        }
+                        else
+                        {
+                            ss << "\"" << key << "\"";
+                        }
+                        ss << ": " << to_log_string(prop_val, 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,43 @@
+#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())
+                // THROW
+                Exception::throw_uninitialized_reference("#<Object>");
+            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
+        }
+    }
+}