@ugo-studio/jspp 0.1.4 → 0.1.6

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

@@ -17,18 +17,21 @@ namespace jspp
         {
             auto obj = val.as_object();
 
-            size_t prop_count = obj->props.size();
+            size_t prop_count = obj->storage.size();
             bool use_horizontal_layout = prop_count > 0 && prop_count <= HORIZONTAL_OBJECT_MAX_PROPS;
 
-            if (use_horizontal_layout)
+            for (size_t i = 0; i < obj->storage.size(); ++i)
             {
-                for (const auto &pair : obj->props)
+                const auto& prop_val = obj->storage[i];
+                if (!is_enumerable_property(prop_val))
                 {
-                    if (!is_simple_value(pair.second))
-                    {
-                        use_horizontal_layout = false;
-                        break;
-                    }
+                    prop_count--;
+                    continue;
+                }
+                if (use_horizontal_layout && !is_simple_value(prop_val))
+                {
+                    use_horizontal_layout = false;
+                    break;
                 }
             }
 
@@ -39,13 +42,19 @@ namespace jspp
             // Special handling for Error objects
             try
             {
-                auto is_error = isErrorFn.as_function()->call(isErrorFn, {val}).is_truthy();
+                const AnyValue args[] = {val};
+                auto is_error = is_truthy(isErrorFn.call(isErrorFn, std::span<const AnyValue>(args, 1)));
                 if (is_error)
                 {
-                    auto result = errorToStringFn.as_function()->call(val, {});
+                    auto result = errorToStringFn.call(val, std::span<const AnyValue>{});
                     if (result.is_string())
                     {
-                        ss << result.to_std_string() << " ";
+                        ss << result.to_std_string();
+                        if (prop_count == 0)
+                        {
+                            return ss.str();
+                        }
+                        ss << " ";
                     }
                 }
             }
@@ -58,20 +67,23 @@ namespace jspp
             {
                 ss << "{ ";
                 size_t current_prop = 0;
-                for (const auto &pair : obj->props)
+                for (size_t i = 0; i < obj->shape->property_names.size(); ++i)
                 {
-                    if (!is_enumerable_property(pair.second))
+                    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(pair.first))
+                    if (is_valid_js_identifier(key))
                     {
-                        ss << pair.first;
+                        ss << key;
                     }
                     else
                     {
-                        ss << "\"" << pair.first << "\"";
+                        ss << "\"" << key << "\"";
                     }
-                    ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                    ss << ": " << to_log_string(prop_val, visited, depth + 1);
                     if (++current_prop < prop_count)
                         ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
                 }
@@ -84,25 +96,30 @@ namespace jspp
                 {
                     ss << "\n";
                     size_t props_shown = 0;
-                    for (const auto &pair : obj->props)
+                    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";
-                        if (!is_enumerable_property(pair.second))
-                            continue;
 
                         ss << next_indent;
-                        if (is_valid_js_identifier(pair.first))
+                        if (is_valid_js_identifier(key))
                         {
-                            ss << pair.first;
+                            ss << key;
                         }
                         else
                         {
-                            ss << "\"" << pair.first << "\"";
+                            ss << "\"" << key << "\"";
                         }
-                        ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                        ss << ": " << to_log_string(prop_val, visited, depth + 1);
                         props_shown++;
                     }
                     if (prop_count > MAX_OBJECT_PROPS)

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

@@ -1,4 +1,5 @@
 #pragma once
+
 #include "types.hpp"
 #include "any_value.hpp"
 #include "utils/log_any_value/config.hpp"
@@ -13,7 +14,8 @@ namespace jspp
         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;
+                // THROW
+                Exception::throw_uninitialized_reference("#<Object>");
             if (val.is_undefined())
                 return Color::BRIGHT_BLACK + std::string("undefined") + Color::RESET;
             if (val.is_null())