@ugo-studio/jspp 0.2.6 → 0.2.8

package/src/prelude/utils/access.hpp

@@ -306,32 +306,88 @@ namespace jspp
             return Constants::TRUE;
         }
 
-        inline AnyValue optional_get_property(const AnyValue &obj, const std::string &key)
+        inline AnyValue get_optional_property(const AnyValue &obj, const std::string &key)
         {
             if (obj.is_null() || obj.is_undefined())
                 return Constants::UNDEFINED;
             return obj.get_own_property(key);
         }
 
-        inline AnyValue optional_get_element(const AnyValue &obj, const AnyValue &key)
+        inline AnyValue get_optional_element(const AnyValue &obj, const AnyValue &key)
         {
             if (obj.is_null() || obj.is_undefined())
                 return Constants::UNDEFINED;
             return obj.get_own_property(key);
         }
 
-        inline AnyValue optional_get_element(const AnyValue &obj, const double &key)
+        inline AnyValue get_optional_element(const AnyValue &obj, const double &key)
         {
             if (obj.is_null() || obj.is_undefined())
                 return Constants::UNDEFINED;
             return obj.get_own_property(static_cast<uint32_t>(key));
         }
 
-        inline AnyValue optional_call(const AnyValue &fn, const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &name = std::nullopt)
+        inline AnyValue call_optional_property(const AnyValue &obj, const std::string &key, std::span<const AnyValue> args, const std::optional<std::string> &expr = std::nullopt)
         {
-            if (fn.is_null() || fn.is_undefined())
+            if (obj.is_null() || obj.is_undefined())
                 return Constants::UNDEFINED;
-            return fn.call(thisVal, args, name);
+            return obj.get_own_property(key).call(obj, args, expr);
+        }
+        inline AnyValue call_optional_property_with_optional_call(const AnyValue &obj, const std::string &key, std::span<const AnyValue> args, const std::optional<std::string> &expr = std::nullopt)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(key).optional_call(obj, args, expr);
+        }
+
+        inline void spread_array(std::vector<AnyValue> &target, const AnyValue &source)
+        {
+            if (source.is_array())
+            {
+                auto arr = source.as_array();
+                target.reserve(target.size() + arr->length);
+                for (uint64_t i = 0; i < arr->length; ++i)
+                {
+                    target.push_back(arr->get_property(static_cast<uint32_t>(i)));
+                }
+            }
+            else if (source.is_string())
+            {
+                auto s = source.as_string();
+                target.reserve(target.size() + s->value.length());
+                for (char c : s->value)
+                {
+                    target.push_back(AnyValue::make_string(std::string(1, c)));
+                }
+            }
+            else if (source.is_object() || source.is_function() || source.is_iterator())
+            {
+                auto iter = get_object_value_iterator(source, "spread target");
+                auto next_fn = iter.get_own_property("next");
+                while (true)
+                {
+                    auto next_res = next_fn.call(iter, {});
+                    if (is_truthy(next_res.get_own_property("done")))
+                        break;
+                    target.push_back(next_res.get_own_property("value"));
+                }
+            }
+            else
+            {
+                throw jspp::Exception::make_exception("Spread syntax requires an iterable object", "TypeError");
+            }
+        }
+
+        inline void spread_object(AnyValue &target, const AnyValue &source)
+        {
+            if (source.is_null() || source.is_undefined())
+                return;
+
+            auto keys = get_object_keys(source);
+            for (const auto &key : keys)
+            {
+                target.set_own_property(key, source.get_property_with_receiver(key, source));
+            }
         }
 
     }

package/src/prelude/utils/assignment_operators.hpp

@@ -9,56 +9,56 @@ namespace jspp {
     // --- FRIEND IMPLEMENTATIONS ---
 
     inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = lhs + rhs;
+        lhs = jspp::add(lhs, rhs);
         return lhs;
     }
 
     inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = lhs - rhs;
+        lhs = jspp::sub(lhs, rhs);
         return lhs;
     }
 
     inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = lhs * rhs;
+        lhs = jspp::mul(lhs, rhs);
         return lhs;
     }
 
     inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = lhs / rhs;
+        lhs = jspp::div(lhs, rhs);
         return lhs;
     }
 
     inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = lhs % rhs;
+        lhs = jspp::mod(lhs, rhs);
         return lhs;
     }
 
     inline AnyValue &operator++(AnyValue &val) {
-        val = val + 1.0;
+        val = jspp::add(val, 1.0);
         return val;
     }
 
     inline AnyValue operator++(AnyValue &val, int) {
         AnyValue temp = val;
-        val = val + 1.0;
+        val = jspp::add(val, 1.0);
         return temp;
     }
 
     inline AnyValue &operator--(AnyValue &val) {
-        val = val - 1.0;
+        val = jspp::sub(val, 1.0);
         return val;
     }
 
     inline AnyValue operator--(AnyValue &val, int) {
         AnyValue temp = val;
-        val = val - 1.0;
+        val = jspp::sub(val, 1.0);
         return temp;
     }
 
     // --- OVERLOADS FOR PRIMITIVES ---
 
     inline AnyValue &operator+=(AnyValue &lhs, const double &rhs) {
-        lhs = lhs + rhs;
+        lhs = jspp::add(lhs, rhs);
         return lhs;
     }
     inline AnyValue &operator+=(AnyValue &lhs, const int &rhs) {
@@ -66,7 +66,7 @@ namespace jspp {
     }
 
     inline AnyValue &operator-=(AnyValue &lhs, const double &rhs) {
-        lhs = lhs - rhs;
+        lhs = jspp::sub(lhs, rhs);
         return lhs;
     }
     inline AnyValue &operator-=(AnyValue &lhs, const int &rhs) {
@@ -74,7 +74,7 @@ namespace jspp {
     }
 
     inline AnyValue &operator*=(AnyValue &lhs, const double &rhs) {
-        lhs = lhs * rhs;
+        lhs = jspp::mul(lhs, rhs);
         return lhs;
     }
     inline AnyValue &operator*=(AnyValue &lhs, const int &rhs) {
@@ -82,7 +82,7 @@ namespace jspp {
     }
 
     inline AnyValue &operator/=(AnyValue &lhs, const double &rhs) {
-        lhs = lhs / rhs;
+        lhs = jspp::div(lhs, rhs);
         return lhs;
     }
     inline AnyValue &operator/=(AnyValue &lhs, const int &rhs) {
@@ -90,7 +90,7 @@ namespace jspp {
     }
 
     inline AnyValue &operator%=(AnyValue &lhs, const double &rhs) {
-        lhs = lhs % rhs;
+        lhs = jspp::mod(lhs, rhs);
         return lhs;
     }
     inline AnyValue &operator%=(AnyValue &lhs, const int &rhs) {

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

@@ -20,21 +20,6 @@ namespace jspp
             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;

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

@@ -14,8 +14,10 @@ namespace jspp
         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())