@ugo-studio/jspp 0.1.2 → 0.1.4

package/src/prelude/scheduler.hpp

@@ -0,0 +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;
+        }
+    };
+}

package/src/prelude/types.hpp

@@ -6,6 +6,7 @@
 #include <variant>
 #include <functional>
 #include <memory>
+#include <map>
 #include <unordered_map>
 #include <algorithm>
 #include <cctype>
@@ -17,34 +18,60 @@
 // JSPP standard library
 namespace jspp
 {
-    // Forward declarations
+    // Js value forward declarations
     struct JsUndefined;     // cannot set property
     struct JsNull;          // cannot set property
     struct JsUninitialized; // cannot set property
+    struct JsString;        // can set property
     struct JsObject;        // can set property
     struct JsArray;         // can set property
     struct JsFunction;      // can set property
+    struct JsPromise;       // can set property
+    struct JsSymbol;        // can set property (but usually doesn't have own props)
+
+    template <typename T>
+    class JsIterator; // can set property
 
     // Object property configuration forward declarations
     struct DataDescriptor;
     struct AccessorDescriptor;
 
+    // Custom runtime exception
+    struct Exception;
+
     // Dynamic AnyValue
     class AnyValue;
 
-    // Custom runtime exception
-    struct RuntimeError;
-
     // Arithemetic operators
     inline AnyValue pow(const AnyValue &lhs, const AnyValue &rhs);
 
     // AnyValue prototypes
+    namespace ObjectPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsObject *self);
+    }
     namespace StringPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, const std::unique_ptr<std::string> &self);
+        inline std::optional<AnyValue> get(const std::string &key, JsString *self);
     }
     namespace ArrayPrototypes
     {
         inline std::optional<AnyValue> get(const std::string &key, JsArray *self);
     }
-}
+    namespace FunctionPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsFunction *self);
+    }
+    namespace PromisePrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsPromise *self);
+    }
+    namespace IteratorPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsIterator<AnyValue> *self);
+    }
+    namespace SymbolPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsSymbol *self);
+    }
+}

package/src/prelude/utils/access.hpp

@@ -0,0 +1,174 @@
+#pragma once
+
+#include "types.hpp"
+#include "well_known_symbols.hpp"
+#include "values/function.hpp"
+#include "values/symbol.hpp"
+#include "exception.hpp"
+#include "any_value.hpp"
+#include <ranges>
+
+namespace jspp
+{
+    namespace Access
+    {
+        // Helper function to check for TDZ and deref heap-allocated variables
+        inline const AnyValue &deref_ptr(const std::shared_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+        inline AnyValue &deref_ptr(std::shared_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+        inline const AnyValue &deref_ptr(const std::unique_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+        inline AnyValue &deref_ptr(std::unique_ptr<AnyValue> &var, const std::string &name)
+        {
+            if ((*var).is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return *var;
+        }
+
+        // Helper function to check for TDZ on stack-allocated variables
+        inline const AnyValue &deref_stack(const AnyValue &var, const std::string &name)
+        {
+            if (var.is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return var;
+        }
+        inline AnyValue &deref_stack(AnyValue &var, const std::string &name)
+        {
+            if (var.is_uninitialized()) [[unlikely]]
+            {
+                Exception::throw_uninitialized_reference(name);
+            }
+            return var;
+        }
+
+        inline AnyValue typeof(const AnyValue &val)
+        {
+            switch (val.get_type())
+            {
+            case JsType::Undefined:
+                return AnyValue::make_string("undefined");
+            case JsType::Null:
+                return AnyValue::make_string("object");
+            case JsType::Boolean:
+                return AnyValue::make_string("boolean");
+            case JsType::Number:
+                return AnyValue::make_string("number");
+            case JsType::String:
+                return AnyValue::make_string("string");
+            case JsType::Symbol:
+                return AnyValue::make_string("symbol");
+            case JsType::Function:
+                return AnyValue::make_string("function");
+            case JsType::Object:
+            case JsType::Array:
+            case JsType::Iterator:
+                return AnyValue::make_string("object");
+            default:
+                return AnyValue::make_string("undefined");
+            }
+        }
+        inline AnyValue typeof() // for undeclared variables
+        {
+            return AnyValue::make_string("undefined");
+        }
+
+        // Helper function to get enumerable own property keys/values of an object
+        inline std::vector<std::string> get_object_keys(const AnyValue &obj)
+        {
+            std::vector<std::string> keys;
+
+            if (obj.is_object())
+            {
+                auto ptr = obj.as_object();
+                for (const auto &pair : ptr->props)
+                {
+                    if (!JsSymbol::is_internal_key(pair.first))
+                        keys.push_back(pair.first);
+                }
+            }
+            if (obj.is_function())
+            {
+                auto ptr = obj.as_function();
+                for (const auto &pair : ptr->props)
+                {
+                    if (!JsSymbol::is_internal_key(pair.first))
+                    {
+                        if (!pair.second.is_data_descriptor() && !pair.second.is_accessor_descriptor())
+                            keys.push_back(pair.first);
+                        else if ((pair.second.is_data_descriptor() && pair.second.as_data_descriptor()->enumerable) ||
+                                 (pair.second.is_accessor_descriptor() && pair.second.as_accessor_descriptor()->enumerable))
+                            keys.push_back(pair.first);
+                    }
+                }
+            }
+            if (obj.is_array())
+            {
+                auto len = obj.as_array()->length;
+                for (auto i = 0; i < len; ++i)
+                {
+                    keys.push_back(std::to_string(i));
+                }
+            }
+            if (obj.is_string())
+            {
+                auto len = obj.as_string()->value.length();
+                for (auto i = 0; i < len; ++i)
+                {
+                    keys.push_back(std::to_string(i));
+                }
+            }
+
+            return keys;
+        }
+        inline AnyValue get_object_value_iterator(const AnyValue &obj, const std::string &name)
+        {
+            if (obj.is_iterator())
+            {
+                return obj;
+            }
+
+            auto gen_fn = obj.get_own_property(WellKnownSymbols::iterator->key);
+            if (gen_fn.is_function())
+            {
+                auto iter = gen_fn.as_function()->call(gen_fn, {});
+                if (iter.is_iterator())
+                {
+                    return iter;
+                }
+                if (iter.is_object())
+                {
+                    auto next_fn = iter.get_own_property("next");
+                    if (next_fn.is_function())
+                    {
+                        return iter;
+                    }
+                }
+            }
+
+            throw jspp::Exception::make_exception(name + " is not iterable", "TypeError");
+        }
+    }
+}

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

@@ -0,0 +1,245 @@
+#pragma once
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/log_any_value/config.hpp"
+#include "utils/log_any_value/helpers.hpp"
+#include "utils/log_any_value/fwd.hpp"
+#include <string>
+#include <sstream>
+#include <unordered_set>
+#include <algorithm>
+#include <optional>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        inline std::string format_array(const AnyValue &val, std::unordered_set<const void *> &visited, int depth)
+        {
+            auto arr = val.as_array();
+            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;
+
+            // Horizontal layout for small and simple arrays
+            bool use_horizontal_layout = item_count <= HORIZONTAL_ARRAY_MAX_ITEMS;
+            if (use_horizontal_layout)
+            {
+                for (size_t i = 0; i < item_count; ++i)
+                {
+                    std::optional<AnyValue> itemVal;
+                    if (i < arr->dense.size())
+                    {
+                        itemVal = arr->dense[i];
+                    }
+                    else
+                    {
+                        auto it = arr->sparse.find(static_cast<uint32_t>(i));
+                        if (it != arr->sparse.end())
+                        {
+                            itemVal = it->second;
+                        }
+                    }
+                    if (itemVal.has_value() && !is_simple_value(itemVal.value()))
+                    {
+                        use_horizontal_layout = false;
+                        break;
+                    }
+                }
+            }
+
+            if (use_horizontal_layout)
+            {
+                ss << "[ ";
+                size_t empty_count = 0;
+                bool needs_comma = false;
+
+                for (size_t i = 0; i < item_count; ++i)
+                {
+                    std::optional<AnyValue> itemVal;
+                    if (i < arr->dense.size())
+                    {
+                        itemVal = arr->dense[i];
+                    }
+                    else
+                    {
+                        auto it = arr->sparse.find(static_cast<uint32_t>(i));
+                        if (it != arr->sparse.end())
+                        {
+                            itemVal = it->second;
+                        }
+                    }
+
+                    if (itemVal.has_value())
+                    {
+                        if (empty_count > 0)
+                        {
+                            if (needs_comma)
+                                ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                            ss << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                            needs_comma = true;
+                            empty_count = 0;
+                        }
+                        if (needs_comma)
+                            ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                        ss << to_log_string(itemVal.value(), visited, depth + 1);
+                        needs_comma = true;
+                    }
+                    else
+                    {
+                        empty_count++;
+                    }
+                }
+
+                if (empty_count > 0)
+                {
+                    if (needs_comma)
+                        ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                    ss << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                }
+
+                // Print properties
+                if (prop_count > 0)
+                {
+                    ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+
+                    size_t current_prop = 0;
+                    for (const auto &pair : arr->props)
+                    {
+                        if (!is_enumerable_property(pair.second))
+                            continue;
+
+                        if (is_valid_js_identifier(pair.first))
+                        {
+                            ss << pair.first;
+                        }
+                        else
+                        {
+                            ss << "\"" << pair.first << "\"";
+                        }
+                        ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                        if (++current_prop < prop_count)
+                            ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
+                    }
+                }
+
+                ss << " ]";
+                return ss.str();
+            }
+
+            // Bun-like multi-line layout
+            ss << "[\n";
+
+            const size_t items_to_show = std::min(item_count, MAX_ARRAY_ITEMS);
+            size_t empty_count = 0;
+            bool first_item_printed = false;
+
+            for (size_t i = 0; i < items_to_show; ++i)
+            {
+                std::optional<AnyValue> itemVal;
+                if (i < arr->dense.size())
+                {
+                    itemVal = arr->dense[i];
+                }
+                else
+                {
+                    auto it = arr->sparse.find(static_cast<uint32_t>(i));
+                    if (it != arr->sparse.end())
+                    {
+                        itemVal = it->second;
+                    }
+                }
+
+                if (itemVal.has_value())
+                {
+                    if (empty_count > 0)
+                    {
+                        if (first_item_printed)
+                            ss << Color::BRIGHT_BLACK << ",\n"
+                               << Color::RESET;
+                        ss << next_indent << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                        first_item_printed = true;
+                        empty_count = 0;
+                    }
+                    if (first_item_printed)
+                        ss << Color::BRIGHT_BLACK << ",\n"
+                           << Color::RESET;
+                    ss << next_indent << to_log_string(itemVal.value(), visited, depth + 1);
+                    first_item_printed = true;
+                }
+                else
+                {
+                    empty_count++;
+                }
+            }
+
+            if (empty_count > 0)
+            {
+                if (first_item_printed)
+                    ss << Color::BRIGHT_BLACK << ",\n"
+                       << Color::RESET;
+                ss << next_indent << Color::BRIGHT_BLACK << empty_count << " x empty item" << (empty_count > 1 ? "s" : "") << Color::RESET;
+                first_item_printed = true;
+            }
+
+            if (item_count > items_to_show)
+            {
+                if (first_item_printed)
+                    ss << Color::BRIGHT_BLACK << ",\n"
+                       << Color::RESET;
+                ss << next_indent << Color::BRIGHT_BLACK << "... " << (item_count - items_to_show) << " more items" << Color::RESET;
+            }
+            // Print properties
+            else if (prop_count > 0)
+            {
+                if (first_item_printed)
+                    ss << Color::BRIGHT_BLACK << ",\n"
+                       << Color::RESET;
+
+                size_t current_prop = 0;
+                for (const auto &pair : arr->props)
+                {
+                    if (current_prop >= MAX_OBJECT_PROPS)
+                        break;
+                    if (!is_enumerable_property(pair.second))
+                        continue;
+
+                    ss << next_indent;
+                    if (is_valid_js_identifier(pair.first))
+                    {
+                        ss << pair.first;
+                    }
+                    else
+                    {
+                        ss << "\"" << pair.first << "\"";
+                    }
+                    ss << ": " << to_log_string(pair.second, visited, depth + 1);
+                    if (++current_prop < prop_count)
+                        ss << Color::BRIGHT_BLACK << ",\n"
+                           << Color::RESET;
+                }
+            }
+            ss << "\n";
+            ss << indent << "]";
+            return ss.str();
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <string>
+
+namespace jspp
+{
+    namespace LogAnyValue
+    {
+        // --- Configuration for Logging Verbosity ---
+        const int MAX_DEPTH = 5;
+        const size_t MAX_STRING_LENGTH = 100;
+        const size_t MAX_ARRAY_ITEMS = 50;
+        const size_t MAX_OBJECT_PROPS = 30;
+
+        // --- Configuration for Horizontal Layout ---
+        const size_t HORIZONTAL_ARRAY_MAX_ITEMS = 10;
+        const size_t HORIZONTAL_OBJECT_MAX_PROPS = 5;
+
+        // ANSI Color Codes for terminal output
+        namespace Color
+        {
+            const std::string RESET = "\033[0m";
+            const std::string RED = "\033[31m";
+            const std::string GREEN = "\033[32m";
+            const std::string YELLOW = "\033[33m";
+            const std::string BLUE = "\033[94m";
+            const std::string CYAN = "\033[36m";
+            const std::string MAGENTA = "\033[35m";
+            const std::string BRIGHT_BLACK = "\033[90m"; // Grey
+        }
+    }
+}