@ugo-studio/jspp 0.2.5 → 0.2.7

package/src/prelude/scheduler.hpp

@@ -1,145 +1,145 @@
-#pragma once
-#include <deque>
-#include <functional>
-#include <chrono>
-#include <queue>
-#include <unordered_set>
-#include <vector>
-#include <thread>
-#include <iostream>
-
-namespace jspp {
-    class Scheduler {
-    public:
-        using Task = std::function<void()>;
-        using TimePoint = std::chrono::steady_clock::time_point;
-        
-        struct Timer {
-            size_t id;
-            TimePoint next_run;
-            std::chrono::milliseconds interval; // 0 if not repeating
-            Task task;
-            
-            // Min-heap priority queue (smallest time at top)
-            bool operator>(const Timer& other) const {
-                return next_run > other.next_run;
-            }
-        };
-
-        static Scheduler& instance() {
-            static Scheduler s;
-            return s;
-        }
-
-        void enqueue(Task task) {
-            tasks.push_back(std::move(task));
-        }
-
-        size_t set_timeout(Task task, size_t delay_ms) {
-            return schedule_timer(std::move(task), delay_ms, false);
-        }
-
-        size_t set_interval(Task task, size_t delay_ms) {
-             return schedule_timer(std::move(task), delay_ms, true);
-        }
-        
-        void clear_timer(size_t id) {
-            cancelled_timers.insert(id);
-        }
-
-        void run() {
-            while (true) {
-                bool has_work = false;
-
-                // 1. Process all immediate tasks (microtask/task queue)
-                while (!tasks.empty()) {
-                    Task task = tasks.front();
-                    tasks.pop_front();
-                    task();
-                    has_work = true;
-                }
-
-                // 2. Process timers
-                auto now = std::chrono::steady_clock::now();
-                while (!timers.empty()) {
-                    // Peek top
-                    const auto& top = timers.top();
-                    
-                    // Cleanup cancelled timers lazily
-                    if (cancelled_timers.count(top.id)) {
-                        cancelled_timers.erase(top.id);
-                        timers.pop();
-                        continue;
-                    }
-                    
-                    if (top.next_run <= now) {
-                        // Timer is ready
-                        Timer t = top;
-                        timers.pop();
-                        
-                        // Execute task
-                        t.task();
-                        has_work = true;
-                        
-                        // Reschedule if interval and not cancelled during execution
-                        if (t.interval.count() > 0 && cancelled_timers.find(t.id) == cancelled_timers.end()) {
-                            // Drift-safe(ish) scheduling: run next interval relative to now
-                            // Note: JS allows drift.
-                            t.next_run = std::chrono::steady_clock::now() + t.interval;
-                            timers.push(t);
-                        }
-                    } else {
-                        break; // Next timer is in the future
-                    }
-                }
-
-                // 3. Exit or Wait
-                if (!has_work) {
-                    if (tasks.empty() && timers.empty()) {
-                        break; // No pending work, exit event loop
-                    }
-                    
-                    if (!timers.empty()) {
-                        auto next_time = timers.top().next_run;
-                        std::this_thread::sleep_until(next_time);
-                    }
-                }
-            }
-        }
-        
-        bool has_tasks() const {
-            return !tasks.empty() || !timers.empty();
-        }
-
-    private:
-        std::deque<Task> tasks;
-        std::priority_queue<Timer, std::vector<Timer>, std::greater<Timer>> timers;
-        std::unordered_set<size_t> cancelled_timers;
-        size_t next_timer_id = 1;
-        const size_t MAX_TIMER_ID = 2147483647; // 2^31 - 1
-
-        size_t schedule_timer(Task task, size_t delay_ms, bool repeat) {
-            size_t id = next_timer_id++;
-            if (next_timer_id > MAX_TIMER_ID) {
-                next_timer_id = 1;
-            }
-            
-            // If we wrap around, ensure we don't accidentally treat this new ID as cancelled
-            // (in case an old timer with this ID is still lingering in the 'cancelled' set)
-            if (cancelled_timers.count(id)) {
-                cancelled_timers.erase(id);
-            }
-            
-            auto now = std::chrono::steady_clock::now();
-            
-            Timer t;
-            t.id = id;
-            t.next_run = now + std::chrono::milliseconds(delay_ms);
-            t.interval = repeat ? std::chrono::milliseconds(delay_ms) : std::chrono::milliseconds(0);
-            t.task = std::move(task);
-            
-            timers.push(t);
-            return id;
-        }
-    };
+#pragma once
+#include <deque>
+#include <functional>
+#include <chrono>
+#include <queue>
+#include <unordered_set>
+#include <vector>
+#include <thread>
+#include <iostream>
+
+namespace jspp {
+    class Scheduler {
+    public:
+        using Task = std::function<void()>;
+        using TimePoint = std::chrono::steady_clock::time_point;
+        
+        struct Timer {
+            size_t id;
+            TimePoint next_run;
+            std::chrono::milliseconds interval; // 0 if not repeating
+            Task task;
+            
+            // Min-heap priority queue (smallest time at top)
+            bool operator>(const Timer& other) const {
+                return next_run > other.next_run;
+            }
+        };
+
+        static Scheduler& instance() {
+            static Scheduler s;
+            return s;
+        }
+
+        void enqueue(Task task) {
+            tasks.push_back(std::move(task));
+        }
+
+        size_t set_timeout(Task task, size_t delay_ms) {
+            return schedule_timer(std::move(task), delay_ms, false);
+        }
+
+        size_t set_interval(Task task, size_t delay_ms) {
+             return schedule_timer(std::move(task), delay_ms, true);
+        }
+        
+        void clear_timer(size_t id) {
+            cancelled_timers.insert(id);
+        }
+
+        void run() {
+            while (true) {
+                bool has_work = false;
+
+                // 1. Process all immediate tasks (microtask/task queue)
+                while (!tasks.empty()) {
+                    Task task = tasks.front();
+                    tasks.pop_front();
+                    task();
+                    has_work = true;
+                }
+
+                // 2. Process timers
+                auto now = std::chrono::steady_clock::now();
+                while (!timers.empty()) {
+                    // Peek top
+                    const auto& top = timers.top();
+                    
+                    // Cleanup cancelled timers lazily
+                    if (cancelled_timers.count(top.id)) {
+                        cancelled_timers.erase(top.id);
+                        timers.pop();
+                        continue;
+                    }
+                    
+                    if (top.next_run <= now) {
+                        // Timer is ready
+                        Timer t = top;
+                        timers.pop();
+                        
+                        // Execute task
+                        t.task();
+                        has_work = true;
+                        
+                        // Reschedule if interval and not cancelled during execution
+                        if (t.interval.count() > 0 && cancelled_timers.find(t.id) == cancelled_timers.end()) {
+                            // Drift-safe(ish) scheduling: run next interval relative to now
+                            // Note: JS allows drift.
+                            t.next_run = std::chrono::steady_clock::now() + t.interval;
+                            timers.push(t);
+                        }
+                    } else {
+                        break; // Next timer is in the future
+                    }
+                }
+
+                // 3. Exit or Wait
+                if (!has_work) {
+                    if (tasks.empty() && timers.empty()) {
+                        break; // No pending work, exit event loop
+                    }
+                    
+                    if (!timers.empty()) {
+                        auto next_time = timers.top().next_run;
+                        std::this_thread::sleep_until(next_time);
+                    }
+                }
+            }
+        }
+        
+        bool has_tasks() const {
+            return !tasks.empty() || !timers.empty();
+        }
+
+    private:
+        std::deque<Task> tasks;
+        std::priority_queue<Timer, std::vector<Timer>, std::greater<Timer>> timers;
+        std::unordered_set<size_t> cancelled_timers;
+        size_t next_timer_id = 1;
+        const size_t MAX_TIMER_ID = 2147483647; // 2^31 - 1
+
+        size_t schedule_timer(Task task, size_t delay_ms, bool repeat) {
+            size_t id = next_timer_id++;
+            if (next_timer_id > MAX_TIMER_ID) {
+                next_timer_id = 1;
+            }
+            
+            // If we wrap around, ensure we don't accidentally treat this new ID as cancelled
+            // (in case an old timer with this ID is still lingering in the 'cancelled' set)
+            if (cancelled_timers.count(id)) {
+                cancelled_timers.erase(id);
+            }
+            
+            auto now = std::chrono::steady_clock::now();
+            
+            Timer t;
+            t.id = id;
+            t.next_run = now + std::chrono::milliseconds(delay_ms);
+            t.interval = repeat ? std::chrono::milliseconds(delay_ms) : std::chrono::milliseconds(0);
+            t.task = std::move(task);
+            
+            timers.push(t);
+            return id;
+        }
+    };
 }

package/src/prelude/types.hpp

@@ -146,34 +146,34 @@ namespace jspp
     // AnyValue prototypes
     namespace ObjectPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, JsObject *self);
+        inline std::optional<AnyValue> get(const std::string &key);
     }
     namespace StringPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, JsString *self);
+        inline std::optional<AnyValue> get(const std::string &key);
     }
     namespace NumberPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, double self);
+        inline std::optional<AnyValue> get(const std::string &key);
     }
     namespace ArrayPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, JsArray *self);
+        inline std::optional<AnyValue> get(const std::string &key);
     }
     namespace FunctionPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, JsFunction *self);
+        inline std::optional<AnyValue> get(const std::string &key);
     }
     namespace PromisePrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, JsPromise *self);
+        inline std::optional<AnyValue> get(const std::string &key);
     }
     namespace IteratorPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, JsIterator<AnyValue> *self);
+        inline std::optional<AnyValue> get(const std::string &key);
     }
     namespace SymbolPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, JsSymbol *self);
+        inline std::optional<AnyValue> get(const std::string &key);
     }
 }

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/object.hpp

@@ -22,7 +22,7 @@ namespace jspp
 
             for (size_t i = 0; i < obj->storage.size(); ++i)
             {
-                const auto& prop_val = obj->storage[i];
+                const auto &prop_val = obj->storage[i];
                 if (!is_enumerable_property(prop_val))
                 {
                     prop_count--;
@@ -69,8 +69,8 @@ namespace jspp
                 size_t current_prop = 0;
                 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];
+                    const auto &key = obj->shape->property_names[i];
+                    const auto &prop_val = obj->storage[i];
 
                     if (!is_enumerable_property(prop_val))
                         continue;
@@ -81,9 +81,10 @@ namespace jspp
                     }
                     else
                     {
-                        ss << "\"" << key << "\"";
+                        ss << Color::GREEN << "\"" << key << "\"" << Color::RESET;
                     }
-                    ss << ": " << to_log_string(prop_val, visited, depth + 1);
+                    ss << Color::BRIGHT_BLACK << ": " << Color::RESET;
+                    ss << to_log_string(prop_val, visited, depth + 1);
                     if (++current_prop < prop_count)
                         ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
                 }
@@ -98,12 +99,12 @@ namespace jspp
                     size_t props_shown = 0;
                     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];
+                        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;
 
@@ -117,9 +118,10 @@ namespace jspp
                         }
                         else
                         {
-                            ss << "\"" << key << "\"";
+                            ss << Color::GREEN << "\"" << key << "\"" << Color::RESET;
                         }
-                        ss << ": " << to_log_string(prop_val, visited, depth + 1);
+                        ss << Color::BRIGHT_BLACK << ": " << Color::RESET;
+                        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

@@ -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())