@ugo-studio/jspp 0.2.4 → 0.2.6

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/utils/access.hpp

@@ -231,7 +231,7 @@ namespace jspp
             {
                 throw jspp::Exception::make_exception("Function has non-object prototype in instanceof check", "TypeError");
             }
-            
+
             AnyValue current = lhs;
 
             while (true)
@@ -253,7 +253,7 @@ namespace jspp
                 {
                     break;
                 }
-                
+
                 if (proto.is_null() || proto.is_undefined())
                     break;
                 if (is_strictly_equal_to_primitive(proto, targetProto))

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

@@ -27,7 +27,14 @@ namespace jspp
             if (val.is_symbol())
                 return Color::BLUE + val.to_std_string() + Color::RESET;
             if (val.is_accessor_descriptor())
+            {
+                auto desc = val.as_accessor_descriptor();
+                if (desc->get.has_value() && !desc->set.has_value())
+                    return Color::BLUE + std::string("[Getter]") + Color::RESET;
+                if (!desc->get.has_value() && desc->set.has_value())
+                    return Color::BLUE + std::string("[Setter]") + Color::RESET;
                 return Color::BLUE + std::string("[Getter/Setter]") + Color::RESET;
+            }
 
             if (val.is_string())
             {

package/src/prelude/utils/operators.hpp

@@ -93,16 +93,14 @@ namespace jspp
     {
         switch (val.get_type())
         {
-        case JsType::Boolean:
-            return val.as_boolean();
         case JsType::Number:
             return is_truthy(val.as_double());
         case JsType::String:
-            return !val.as_string()->value.empty();
-        case JsType::Undefined:
-            return false;
+            return is_truthy(val.as_string()->value);
+        case JsType::Boolean:
+            return val.as_boolean();
         case JsType::Null:
-            return false;
+        case JsType::Undefined:
         case JsType::Uninitialized:
             return false;
         default:

package/src/prelude/values/prototypes/function.hpp

@@ -20,6 +20,24 @@ namespace jspp
                                                key);
             }
 
+            // --- call() method ---
+            if (key == "call")
+            {
+                return AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                {
+                    AnyValue thisArg = Constants::UNDEFINED;
+                    std::span<const AnyValue> fnArgs;
+
+                    if (!args.empty())
+                    {
+                        thisArg = args[0];
+                        fnArgs = args.subspan(1);
+                    }
+
+                    return thisVal.call(thisArg, fnArgs);
+                }, key);
+            }
+
             return std::nullopt;
         }
     }