@ugo-studio/jspp 0.1.3 → 0.1.4

package/src/prelude/utils/access.hpp

@@ -0,0 +1,174 @@
+#pragma once
+
+#include "types.hpp"
+#include "well_known_symbols.hpp"
+#include "values/function.hpp"
+#include "values/symbol.hpp"
+#include "exception.hpp"
+#include "any_value.hpp"
+#include <ranges>
+
+namespace jspp
+{
+    namespace Access
+    {
+        // Helper function to check for TDZ and deref heap-allocated variables
+        inline const AnyValue &deref_ptr(const std::shared_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+        inline AnyValue &deref_ptr(std::shared_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+        inline const AnyValue &deref_ptr(const std::unique_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+        inline AnyValue &deref_ptr(std::unique_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+
+        // Helper function to check for TDZ on stack-allocated variables
+        inline const AnyValue &deref_stack(const AnyValue &var, const std::string &name)
+        {
+            if (var.is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return var;
+        }
+        inline AnyValue &deref_stack(AnyValue &var, const std::string &name)
+        {
+            if (var.is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return var;
+        }
+
+        inline AnyValue typeof(const AnyValue &val)
+        {
+            switch (val.get_type())
+            {
+            case JsType::Undefined:
+                return AnyValue::make_string("undefined");
+            case JsType::Null:
+                return AnyValue::make_string("object");
+            case JsType::Boolean:
+                return AnyValue::make_string("boolean");
+            case JsType::Number:
+                return AnyValue::make_string("number");
+            case JsType::String:
+                return AnyValue::make_string("string");
+            case JsType::Symbol:
+                return AnyValue::make_string("symbol");
+            case JsType::Function:
+                return AnyValue::make_string("function");
+            case JsType::Object:
+            case JsType::Array:
+            case JsType::Iterator:
+                return AnyValue::make_string("object");
+            default:
+                return AnyValue::make_string("undefined");
+            }
+        }
+        inline AnyValue typeof() // for undeclared variables
+        {
+            return AnyValue::make_string("undefined");
+        }
+
+        // Helper function to get enumerable own property keys/values of an object
+        inline std::vector<std::string> get_object_keys(const AnyValue &obj)
+        {
+            std::vector<std::string> keys;
+
+            if (obj.is_object())
+            {
+                auto ptr = obj.as_object();
+                for (const auto &pair : ptr->props)
+                {
+                    if (!JsSymbol::is_internal_key(pair.first))
+                        keys.push_back(pair.first);
+                }
+            }
+            if (obj.is_function())
+            {
+                auto ptr = obj.as_function();
+                for (const auto &pair : ptr->props)
+                {
+                    if (!JsSymbol::is_internal_key(pair.first))
+                    {
+                        if (!pair.second.is_data_descriptor() && !pair.second.is_accessor_descriptor())
+                            keys.push_back(pair.first);
+                        else if ((pair.second.is_data_descriptor() && pair.second.as_data_descriptor()->enumerable) ||
+                                 (pair.second.is_accessor_descriptor() && pair.second.as_accessor_descriptor()->enumerable))
+                            keys.push_back(pair.first);
+                    }
+                }
+            }
+            if (obj.is_array())
+            {
+                auto len = obj.as_array()->length;
+                for (auto i = 0; i < len; ++i)
+                {
+                    keys.push_back(std::to_string(i));
+                }
+            }
+            if (obj.is_string())
+            {
+                auto len = obj.as_string()->value.length();
+                for (auto i = 0; i < len; ++i)
+                {
+                    keys.push_back(std::to_string(i));
+                }
+            }
+
+            return keys;
+        }
+        inline AnyValue get_object_value_iterator(const AnyValue &obj, const std::string &name)
+        {
+            if (obj.is_iterator())
+            {
+                return obj;
+            }
+
+            auto gen_fn = obj.get_own_property(WellKnownSymbols::iterator->key);
+            if (gen_fn.is_function())
+            {
+                auto iter = gen_fn.as_function()->call(gen_fn, {});
+                if (iter.is_iterator())
+                {
+                    return iter;
+                }
+                if (iter.is_object())
+                {
+                    auto next_fn = iter.get_own_property("next");
+                    if (next_fn.is_function())
+                    {
+                        return iter;
+                    }
+                }
+            }
+
+            throw jspp::Exception::make_exception(name + " is not iterable", "TypeError");
+        }
+    }
+}

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

@@ -0,0 +1,245 @@
+#pragma once
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/log_any_value/config.hpp"
+#include "utils/log_any_value/helpers.hpp"
+#include "utils/log_any_value/fwd.hpp"
+#include <string>
+#include <sstream>
+#include <unordered_set>
+#include <algorithm>
+#include <optional>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        inline std::string format_array(const AnyValue &val, std::unordered_set<const void *> &visited, int depth)
+        {
+            auto arr = val.as_array();
+            size_t item_count = static_cast<size_t>(arr->length);
+            size_t prop_count = arr->props.size();
+
+            // // If custom toString exists on the object, prefer it
+            // auto itToString = arr->props.find("toString");
+            // if (depth > 0 && itToString != arr->props.end() && itToString->second.is_function())
+            // {
+            //     try
+            //     {
+            //         auto result = itToString->second.as_function()->call(itToString->second, {});
+            //         return to_log_string(result, visited, depth);
+            //     }
+            //     catch (...)
+            //     {
+            //         // ignore and fallback to manual formatting
+            //     }
+            // }
+
+            std::string indent(depth * 2, ' ');
+            std::string next_indent((depth + 1) * 2, ' ');
+            std::stringstream ss;
+
+            // Horizontal layout for small and simple arrays
+            bool use_horizontal_layout = item_count <= HORIZONTAL_ARRAY_MAX_ITEMS;
+            if (use_horizontal_layout)
+            {
+                for (size_t i = 0; i < item_count; ++i)
+                {
+                    std::optional<AnyValue> itemVal;
+                    if (i < arr->dense.size())
+                    {
+                        itemVal = arr->dense[i];
+                    }
+                    else
+                    {
+                        auto it = arr->sparse.find(static_cast<uint32_t>(i));
+                        if (it != arr->sparse.end())
+                        {
+                            itemVal = it->second;
+                        }
+                    }
+                    if (itemVal.has_value() && !is_simple_value(itemVal.value()))
+                    {
+                        use_horizontal_layout = false;
+                        break;
+                    }
+                }
+            }
+
+            if (use_horizontal_layout)
+            {
+                ss << "[ ";
+                size_t empty_count = 0;
+                bool needs_comma = false;
+
+                for (size_t i = 0; i < item_count; ++i)
+                {
+                    std::optional<AnyValue> itemVal;
+                    if (i < arr->dense.size())
+                    {
+                        itemVal = arr->dense[i];
+                    }
+                    else
+                    {
+                        auto it = arr->sparse.find(static_cast<uint32_t>(i));
+                        if (it != arr->sparse.end())
+                        {
+                            itemVal = it->second;
+                        }
+                    }
+
+                    if (itemVal.has_value())
+                    {
+                        if (empty_count > 0)
+                        {
+                            if (needs_comma)
+                                ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                            ss << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                            needs_comma = true;
+                            empty_count = 0;
+                        }
+                        if (needs_comma)
+                            ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                        ss << to_log_string(itemVal.value(), visited, depth + 1);
+                        needs_comma = true;
+                    }
+                    else
+                    {
+                        empty_count++;
+                    }
+                }
+
+                if (empty_count > 0)
+                {
+                    if (needs_comma)
+                        ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                    ss << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                }
+
+                // Print properties
+                if (prop_count > 0)
+                {
+                    ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+
+                    size_t current_prop = 0;
+                    for (const auto &pair : arr->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 << " ]";
+                return ss.str();
+            }
+
+            // Bun-like multi-line layout
+            ss << "[\n";
+
+            const size_t items_to_show = std::min(item_count, MAX_ARRAY_ITEMS);
+            size_t empty_count = 0;
+            bool first_item_printed = false;
+
+            for (size_t i = 0; i < items_to_show; ++i)
+            {
+                std::optional<AnyValue> itemVal;
+                if (i < arr->dense.size())
+                {
+                    itemVal = arr->dense[i];
+                }
+                else
+                {
+                    auto it = arr->sparse.find(static_cast<uint32_t>(i));
+                    if (it != arr->sparse.end())
+                    {
+                        itemVal = it->second;
+                    }
+                }
+
+                if (itemVal.has_value())
+                {
+                    if (empty_count > 0)
+                    {
+                        if (first_item_printed)
+                            ss << Color::BRIGHT_BLACK << ",\n"
+                               << Color::RESET;
+                        ss << next_indent << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                        first_item_printed = true;
+                        empty_count = 0;
+                    }
+                    if (first_item_printed)
+                        ss << Color::BRIGHT_BLACK << ",\n"
+                           << Color::RESET;
+                    ss << next_indent << to_log_string(itemVal.value(), visited, depth + 1);
+                    first_item_printed = true;
+                }
+                else
+                {
+                    empty_count++;
+                }
+            }
+
+            if (empty_count > 0)
+            {
+                if (first_item_printed)
+                    ss << Color::BRIGHT_BLACK << ",\n"
+                       << Color::RESET;
+                ss << next_indent << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                first_item_printed = true;
+            }
+
+            if (item_count > items_to_show)
+            {
+                if (first_item_printed)
+                    ss << Color::BRIGHT_BLACK << ",\n"
+                       << Color::RESET;
+                ss << next_indent << Color::BRIGHT_BLACK << "... " << (item_count - items_to_show) << " more items" << Color::RESET;
+            }
+            // Print properties
+            else if (prop_count > 0)
+            {
+                if (first_item_printed)
+                    ss << Color::BRIGHT_BLACK << ",\n"
+                       << Color::RESET;
+
+                size_t current_prop = 0;
+                for (const auto &pair : arr->props)
+                {
+                    if (current_prop >= MAX_OBJECT_PROPS)
+                        break;
+                    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);
+                    if (++current_prop < prop_count)
+                        ss << Color::BRIGHT_BLACK << ",\n"
+                           << Color::RESET;
+                }
+            }
+            ss << "\n";
+            ss << indent << "]";
+            return ss.str();
+        }
+    }
+}

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,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();
+        }
+    }
+}