@ugo-studio/jspp 0.1.4 → 0.1.5

package/src/prelude/utils/assignment_operators.hpp

@@ -0,0 +1,99 @@
+#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 = lhs + rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs - rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs * rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs / rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs % rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator++(AnyValue &val) {
+        val = val + 1.0;
+        return val;
+    }
+
+    inline AnyValue operator++(AnyValue &val, int) {
+        AnyValue temp = val;
+        val = val + 1.0;
+        return temp;
+    }
+
+    inline AnyValue &operator--(AnyValue &val) {
+        val = val - 1.0;
+        return val;
+    }
+
+    inline AnyValue operator--(AnyValue &val, int) {
+        AnyValue temp = val;
+        val = val - 1.0;
+        return temp;
+    }
+
+    // --- OVERLOADS FOR PRIMITIVES ---
+
+    inline AnyValue &operator+=(AnyValue &lhs, const double &rhs) {
+        lhs = 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 = 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 = 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 = 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 = 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

@@ -45,7 +45,7 @@ namespace jspp
             {
                 for (size_t i = 0; i < item_count; ++i)
                 {
-                    std::optional<AnyValue> itemVal;
+                    AnyValue itemVal = AnyValue::make_uninitialized();
                     if (i < arr->dense.size())
                     {
                         itemVal = arr->dense[i];
@@ -58,7 +58,7 @@ namespace jspp
                             itemVal = it->second;
                         }
                     }
-                    if (itemVal.has_value() && !is_simple_value(itemVal.value()))
+                    if (!itemVal.is_uninitialized() && !is_simple_value(itemVal))
                     {
                         use_horizontal_layout = false;
                         break;
@@ -74,7 +74,7 @@ namespace jspp
 
                 for (size_t i = 0; i < item_count; ++i)
                 {
-                    std::optional<AnyValue> itemVal;
+                    AnyValue itemVal = AnyValue::make_uninitialized();
                     if (i < arr->dense.size())
                     {
                         itemVal = arr->dense[i];
@@ -88,7 +88,7 @@ namespace jspp
                         }
                     }
 
-                    if (itemVal.has_value())
+                    if (!itemVal.is_uninitialized())
                     {
                         if (empty_count > 0)
                         {
@@ -100,7 +100,7 @@ namespace jspp
                         }
                         if (needs_comma)
                             ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
-                        ss << to_log_string(itemVal.value(), visited, depth + 1);
+                        ss << to_log_string(itemVal, visited, depth + 1);
                         needs_comma = true;
                     }
                     else
@@ -154,7 +154,7 @@ namespace jspp
 
             for (size_t i = 0; i < items_to_show; ++i)
             {
-                std::optional<AnyValue> itemVal;
+                AnyValue itemVal = AnyValue::make_uninitialized();
                 if (i < arr->dense.size())
                 {
                     itemVal = arr->dense[i];
@@ -168,7 +168,7 @@ namespace jspp
                     }
                 }
 
-                if (itemVal.has_value())
+                if (!itemVal.is_uninitialized())
                 {
                     if (empty_count > 0)
                     {
@@ -182,7 +182,7 @@ namespace jspp
                     if (first_item_printed)
                         ss << Color::BRIGHT_BLACK << ",\n"
                            << Color::RESET;
-                    ss << next_indent << to_log_string(itemVal.value(), visited, depth + 1);
+                    ss << next_indent << to_log_string(itemVal, visited, depth + 1);
                     first_item_printed = true;
                 }
                 else

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

@@ -20,17 +20,19 @@ namespace jspp
                     if (fn->proto->is_function())
                     {
                         auto parent = fn->proto->as_function();
-                        if (!parent->name.empty())
+                        std::string name = parent->name.value_or("");
+                        if (!name.empty())
                         {
-                            extends_part = " extends " + parent->name;
+                            extends_part = " extends " + name;
                         }
                     }
                 }
-                return Color::CYAN + std::string("[class ") + (fn->name.empty() ? "(anonymous)" : fn->name) + extends_part + "]" + Color::RESET;
+                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.size() > 0 ? ": " + fn->name : " (anonymous)";
+            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/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())