@ugo-studio/jspp 0.3.0 → 0.3.2

package/src/prelude/utils/assignment_operators.hpp

@@ -1,99 +1,119 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-#include "utils/operators.hpp"
-
-namespace jspp {
-
-    // --- FRIEND IMPLEMENTATIONS ---
-
-    inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::add(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::sub(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::mul(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::div(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::mod(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator++(AnyValue &val) {
-        val = jspp::add(val, 1.0);
-        return val;
-    }
-
-    inline AnyValue operator++(AnyValue &val, int) {
-        AnyValue temp = val;
-        val = jspp::add(val, 1.0);
-        return temp;
-    }
-
-    inline AnyValue &operator--(AnyValue &val) {
-        val = jspp::sub(val, 1.0);
-        return val;
-    }
-
-    inline AnyValue operator--(AnyValue &val, int) {
-        AnyValue temp = val;
-        val = jspp::sub(val, 1.0);
-        return temp;
-    }
-
-    // --- OVERLOADS FOR PRIMITIVES ---
-
-    inline AnyValue &operator+=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::add(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator+=(AnyValue &lhs, const int &rhs) {
-        return lhs += static_cast<double>(rhs);
-    }
-
-    inline AnyValue &operator-=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::sub(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator-=(AnyValue &lhs, const int &rhs) {
-        return lhs -= static_cast<double>(rhs);
-    }
-
-    inline AnyValue &operator*=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::mul(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator*=(AnyValue &lhs, const int &rhs) {
-        return lhs *= static_cast<double>(rhs);
-    }
-
-    inline AnyValue &operator/=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::div(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator/=(AnyValue &lhs, const int &rhs) {
-        return lhs /= static_cast<double>(rhs);
-    }
-
-    inline AnyValue &operator%=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::mod(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator%=(AnyValue &lhs, const int &rhs) {
-        return lhs %= static_cast<double>(rhs);
-    }
-}
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp
+{
+
+    // --- FRIEND IMPLEMENTATIONS ---
+
+    inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::add(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::sub(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::mul(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::div(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::mod(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator++(AnyValue &val)
+    {
+        val = jspp::add(val, 1.0);
+        return val;
+    }
+
+    inline AnyValue operator++(AnyValue &val, int)
+    {
+        AnyValue temp = val;
+        val = jspp::add(val, 1.0);
+        return temp;
+    }
+
+    inline AnyValue &operator--(AnyValue &val)
+    {
+        val = jspp::sub(val, 1.0);
+        return val;
+    }
+
+    inline AnyValue operator--(AnyValue &val, int)
+    {
+        AnyValue temp = val;
+        val = jspp::sub(val, 1.0);
+        return temp;
+    }
+
+    // --- OVERLOADS FOR PRIMITIVES ---
+
+    inline AnyValue &operator+=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::add(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator+=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs += static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator-=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::sub(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator-=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs -= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator*=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::mul(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator*=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs *= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator/=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::div(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator/=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs /= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator%=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::mod(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator%=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs %= static_cast<double>(rhs);
+    }
+}

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

@@ -18,7 +18,7 @@ namespace jspp
         {
             auto arr = val.as_array();
             size_t item_count = static_cast<size_t>(arr->length);
-            size_t prop_count = arr->props.size();
+            size_t prop_count = arr->props.size() + arr->symbol_props.size();
 
             std::string indent(depth * 2, ' ');
             std::string next_indent((depth + 1) * 2, ' ');
@@ -102,28 +102,36 @@ namespace jspp
                 }
 
                 // Print properties
-                if (prop_count > 0)
+                for (const auto &pair : arr->props)
                 {
-                    ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                    if (!is_enumerable_property(pair.second))
+                        continue;
 
-                    size_t current_prop = 0;
-                    for (const auto &pair : arr->props)
-                    {
-                        if (!is_enumerable_property(pair.second))
-                            continue;
+                    if (needs_comma)
+                        ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
 
-                        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;
+                    if (is_valid_js_identifier(pair.first))
+                    {
+                        ss << pair.first;
                     }
+                    else
+                    {
+                        ss << "\"" << pair.first << "\"";
+                    }
+                    ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                    needs_comma = true;
+                }
+                for (const auto &pair : arr->symbol_props)
+                {
+                    if (!is_enumerable_property(pair.second))
+                        continue;
+
+                    if (needs_comma)
+                        ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+
+                    ss << Color::BLUE << pair.first.to_std_string() << Color::RESET;
+                    ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                    needs_comma = true;
                 }
 
                 ss << " ]";
@@ -193,34 +201,47 @@ namespace jspp
                 ss << next_indent << Color::BRIGHT_BLACK << "... " << (item_count - items_to_show) << " more items" << Color::RESET;
             }
             // Print properties
-            else if (prop_count > 0)
+            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;
+
                 if (first_item_printed)
                     ss << Color::BRIGHT_BLACK << ",\n"
                        << Color::RESET;
 
-                size_t current_prop = 0;
-                for (const auto &pair : arr->props)
+                ss << next_indent;
+                if (is_valid_js_identifier(pair.first))
                 {
-                    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 << pair.first;
                 }
+                else
+                {
+                    ss << "\"" << pair.first << "\"";
+                }
+                ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                first_item_printed = true;
+                current_prop++;
+            }
+            for (const auto &pair : arr->symbol_props)
+            {
+                if (current_prop >= MAX_OBJECT_PROPS)
+                    break;
+                if (!is_enumerable_property(pair.second))
+                    continue;
+
+                if (first_item_printed)
+                    ss << Color::BRIGHT_BLACK << ",\n"
+                       << Color::RESET;
+
+                ss << next_indent;
+                ss << Color::BLUE << pair.first.to_std_string() << Color::RESET;
+                ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                first_item_printed = true;
+                current_prop++;
             }
             ss << "\n";
             ss << indent << "]";

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

@@ -1,39 +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.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;
-        }
-    }
-}
+#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.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/log_any_value.hpp

@@ -26,7 +26,7 @@ namespace jspp
         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);
+            auto primitiveStr = format_native(val, depth);
             if (primitiveStr.has_value())
             {
                 return primitiveStr.value();

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

@@ -17,7 +17,7 @@ namespace jspp
         {
             auto obj = val.as_object();
 
-            size_t prop_count = obj->storage.size();
+            size_t prop_count = obj->storage.size() + obj->symbol_props.size();
             bool use_horizontal_layout = prop_count > 0 && prop_count <= HORIZONTAL_OBJECT_MAX_PROPS;
 
             for (size_t i = 0; i < obj->storage.size(); ++i)
@@ -34,19 +34,47 @@ namespace jspp
                     break;
                 }
             }
+            for (const auto &pair : obj->symbol_props)
+            {
+                if (!is_enumerable_property(pair.second))
+                {
+                    prop_count--;
+                    continue;
+                }
+                if (use_horizontal_layout && !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;
+            // ... (omitting intermediate parts for brevity in explanation, but including in replacement)
+            // Use Symbol.toStringTag for object prefix
+            bool has_tag = false;
+            try
+            {
+                auto tag_val = val.get_own_property(AnyValue::from_symbol(WellKnownSymbols::toStringTag));
+                if (tag_val.is_string())
+                {
+                    ss << tag_val.to_std_string() << " ";
+                    has_tag = true;
+                }
+            }
+            catch (...)
+            {
+            }
 
             // Special handling for Error objects
             try
             {
                 const AnyValue args[] = {val};
-                auto is_error = is_truthy(isErrorFn.call(isErrorFn, std::span<const AnyValue>(args, 1)));
+                auto is_error = is_truthy(isErrorFn.call(isErrorFn, std::span<const jspp::AnyValue>(args, 1)));
                 if (is_error)
                 {
-                    auto result = errorToStringFn.call(val, std::span<const AnyValue>{});
+                    auto result = errorToStringFn.call(val, std::span<const jspp::AnyValue>{});
                     if (result.is_string())
                     {
                         ss << result.to_std_string();
@@ -88,6 +116,18 @@ namespace jspp
                     if (++current_prop < prop_count)
                         ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
                 }
+                for (const auto &pair : obj->symbol_props)
+                {
+                    if (!is_enumerable_property(pair.second))
+                        continue;
+
+                    ss << Color::BRIGHT_BLACK << "[" << Color::RESET;
+                    ss << Color::BLUE << pair.first.to_std_string() << Color::RESET;
+                    ss << Color::BRIGHT_BLACK << "]: " << Color::RESET;
+                    ss << to_log_string(pair.second, visited, depth + 1);
+                    if (++current_prop < prop_count)
+                        ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                }
                 ss << " }";
             }
             else
@@ -124,6 +164,23 @@ namespace jspp
                         ss << to_log_string(prop_val, visited, depth + 1);
                         props_shown++;
                     }
+                    for (const auto &pair : obj->symbol_props)
+                    {
+                        if (props_shown >= MAX_OBJECT_PROPS)
+                            break;
+
+                        if (!is_enumerable_property(pair.second))
+                            continue;
+
+                        if (props_shown > 0)
+                            ss << ",\n";
+
+                        ss << next_indent;
+                        ss << Color::BLUE << pair.first.to_std_string() << Color::RESET;
+                        ss << Color::BRIGHT_BLACK << ": " << Color::RESET;
+                        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;

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

@@ -11,7 +11,7 @@ namespace jspp
 {
     namespace LogAnyValue
     {
-        inline std::optional<std::string> format_primitive(const AnyValue &val, int depth)
+        inline std::optional<std::string> format_native(const AnyValue &val, int depth)
         {
             if (val.is_uninitialized())
             {