@ugo-studio/jspp 0.1.2 → 0.1.4

package/src/prelude/values/iterator.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+#include "types.hpp"
+#include <coroutine>
+#include <optional>
+#include <iostream>
+#include <utility>
+#include <exception>
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    template <typename T>
+    class JsIterator
+    {
+    public:
+        struct NextResult
+        {
+            std::optional<T> value;
+            bool done;
+        };
+        struct promise_type
+        {
+            std::optional<T> current_value;
+            std::exception_ptr exception_;
+            T input_value;
+
+            JsIterator get_return_object()
+            {
+                return JsIterator{
+                    std::coroutine_handle<promise_type>::from_promise(*this)};
+            }
+
+            std::suspend_always initial_suspend() noexcept { return {}; }
+
+            // valid js generators allow access to the return value after completion,
+            // so we must suspend at the end to keep the promise (and value) alive.
+            std::suspend_always final_suspend() noexcept { return {}; }
+
+            // Handle co_yield
+            template <typename From>
+            auto yield_value(From &&from)
+            {
+                current_value = std::forward<From>(from);
+                struct Awaiter
+                {
+                    promise_type &p;
+                    bool await_ready() { return false; }
+                    void await_suspend(std::coroutine_handle<promise_type>) {}
+                    T await_resume() { return p.input_value; }
+                };
+                return Awaiter{*this};
+            }
+
+            // Handle co_return
+            // This replaces return_void.
+            // It captures the final value and moves to final_suspend (implicit).
+            template <typename From>
+            void return_value(From &&from)
+            {
+                current_value = std::forward<From>(from);
+            }
+
+            void unhandled_exception()
+            {
+                exception_ = std::current_exception();
+            }
+        };
+
+        using handle_type = std::coroutine_handle<promise_type>;
+        handle_type handle;
+
+        explicit JsIterator(handle_type h) : handle(h) {}
+        JsIterator(JsIterator &&other) noexcept : handle(std::exchange(other.handle, nullptr)) {}
+
+        // Delete copy constructor/assignment to ensure unique ownership of the handle
+        JsIterator(const JsIterator &) = delete;
+        JsIterator &operator=(const JsIterator &) = delete;
+
+        ~JsIterator()
+        {
+            if (handle)
+                handle.destroy();
+        }
+
+        std::unordered_map<std::string, AnyValue> props;
+
+        std::string to_std_string() const;
+        NextResult next(const T &val = T());
+        std::vector<std::optional<T>> to_vector();
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+        AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
+    };
+}

package/src/prelude/values/object.hpp

@@ -4,14 +4,19 @@
 
 namespace jspp
 {
+    // Forward declaration of AnyValue
     class AnyValue;
 
     struct JsObject
     {
-        std::unordered_map<std::string, AnyValue> props;
+        std::map<std::string, AnyValue> props;
+        std::shared_ptr<AnyValue> proto;
+
+        JsObject() : proto(nullptr) {}
+        explicit JsObject(const std::map<std::string, AnyValue> &p, std::shared_ptr<AnyValue> pr = nullptr) : props(p), proto(pr) {}
 
         std::string to_std_string() const;
-        AnyValue get_property(const std::string &key);
-        AnyValue set_property(const std::string &key, const AnyValue &value);
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+        AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
     };
 }

package/src/prelude/values/promise.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "types.hpp"
+#include <vector>
+#include <functional>
+#include <memory>
+#include <variant>
+#include <coroutine>
+#include <unordered_map>
+#include <string>
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    enum class PromiseStatus { Pending, Fulfilled, Rejected };
+
+    struct PromiseState
+    {
+        PromiseStatus status = PromiseStatus::Pending;
+        std::shared_ptr<AnyValue> result; // Value if fulfilled, reason if rejected
+        std::vector<std::function<void(AnyValue)>> onFulfilled;
+        std::vector<std::function<void(AnyValue)>> onRejected;
+        
+        PromiseState(); // Defined in helpers
+    };
+
+    struct JsPromisePromiseType; // Forward declaration
+
+    struct JsPromise
+    {
+        using promise_type = JsPromisePromiseType;
+
+        std::shared_ptr<PromiseState> state;
+        std::unordered_map<std::string, AnyValue> props;
+
+        JsPromise();
+
+        // --- Promise Logic ---
+        void resolve(const AnyValue& value);
+        void reject(const AnyValue& reason);
+        void then(std::function<void(AnyValue)> onFulfilled, std::function<void(AnyValue)> onRejected = nullptr);
+        
+        // --- Methods ---
+        std::string to_std_string() const;
+        AnyValue get_property(const std::string& key, const AnyValue& thisVal);
+        AnyValue set_property(const std::string& key, const AnyValue& value, const AnyValue& thisVal);
+    };
+
+    struct JsPromisePromiseType {
+        JsPromise promise;
+
+        JsPromise get_return_object() { return promise; }
+        std::suspend_never initial_suspend() { return {}; }
+        std::suspend_never final_suspend() noexcept { return {}; }
+        
+        void return_value(const AnyValue& val);
+        
+        void unhandled_exception();
+        
+        // await_transform for AnyValue
+        auto await_transform(const AnyValue& value);
+    };
+    
+    // Awaiter for AnyValue
+    struct AnyValueAwaiter {
+        const AnyValue& value; // Reference to the value being awaited
+        bool await_ready();
+        void await_suspend(std::coroutine_handle<> h);
+        AnyValue await_resume();
+    };
+}

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

@@ -3,8 +3,8 @@
 #include "types.hpp"
 #include "values/array.hpp"
 #include "any_value.hpp"
-#include "error.hpp"
-#include "operators.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
 #include <algorithm>
 #include <vector>
 
@@ -14,24 +14,31 @@ namespace jspp
     {
         inline std::optional<AnyValue> get(const std::string &key, JsArray *self)
         {
-
             // --- toString() method ---
-            if (key == "toString")
+            if (key == "toString" )
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }
 
+            // --- [Symbol.iterator]() method ---
+            if (key == WellKnownSymbols::iterator->key)
+            {
+                return AnyValue::make_generator([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
+                                                { return AnyValue::from_iterator(self->get_iterator()); },
+                                                key);
+            }
+
             // --- length property ---
             if (key == "length")
             {
-                auto getter = [&self](const std::vector<AnyValue> &args) -> AnyValue
+                auto getter = [self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                 {
                     return AnyValue::make_number(self->length);
                 };
 
-                auto setter = [&self](const std::vector<AnyValue> &args) -> AnyValue
+                auto setter = [self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                 {
                     if (args.empty())
                     {
@@ -43,7 +50,7 @@ namespace jspp
 
                     if (new_len_double < 0 || std::isnan(new_len_double) || std::isinf(new_len_double) || new_len_double != static_cast<uint64_t>(new_len_double))
                     {
-                        throw RuntimeError::make_error("Invalid array length", "RangeError");
+                        throw Exception::make_exception("Invalid array length", "RangeError");
                     }
                     uint64_t new_len = static_cast<uint64_t>(new_len_double);
 
@@ -79,7 +86,7 @@ namespace jspp
             // --- push() method ---
             if (key == "push")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            for (const auto &arg : args)
                                                                                            {
@@ -92,7 +99,7 @@ namespace jspp
             // --- pop() method ---
             if (key == "pop")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            if (self->length == 0)
                                                                                            {
@@ -117,7 +124,7 @@ namespace jspp
             // --- shift() method ---
             if (key == "shift")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            if (self->length == 0)
                                                                                            {
@@ -148,7 +155,7 @@ namespace jspp
             // --- unshift() method ---
             if (key == "unshift")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                              size_t args_count = args.size();
                                                                                              if (args_count == 0)
@@ -175,7 +182,7 @@ namespace jspp
             // --- join() method ---
             if (key == "join")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            std::string sep = ",";
                                                                                            if (!args.empty() && !args[0].is_undefined())
@@ -203,11 +210,11 @@ namespace jspp
             // --- forEach() method ---
             if (key == "forEach")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            if (args.empty() || !args[0].is_function())
                                                                                            {
-                                                                                               throw RuntimeError::make_error("callback is not a function", "TypeError");
+                                                                                               throw Exception::make_exception("callback is not a function", "TypeError");
                                                                                            }
                                                                                            auto callback = args[0].as_function();
                                                                                            for (uint64_t i = 0; i < self->length; ++i)
@@ -215,7 +222,7 @@ namespace jspp
                                                                                                AnyValue val = self->get_property(static_cast<uint32_t>(i));
                                                                                                if (!val.is_undefined())
                                                                                                { // forEach skips empty slots
-                                                                                                   callback->call({val, AnyValue::make_number(i)});
+                                                                                                   callback->call(thisVal, {val, AnyValue::make_number(i)});
                                                                                                }
                                                                                            }
                                                                                            return AnyValue::make_undefined(); },

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/function.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp
+{
+    namespace FunctionPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsFunction *self)
+        {
+            // --- toString() method ---
+            if (key == "toString" )
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

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

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/iterator.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp
+{
+    namespace IteratorPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsIterator<AnyValue> *self)
+        {
+            // --- toString() method ---
+            if (key == "toString" )
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+            // --- [Symbol.iterator]() method ---
+            if (key == WellKnownSymbols::iterator->key)
+            {
+                return AnyValue::make_generator([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
+                                                {
+                                                   // An iterator's iterator is itself.
+                                                   // We need to return an AnyValue that holds a shared_ptr to this JsIterator.
+                                                   // Since we only have a raw pointer `self`, we can't directly make a new shared_ptr.
+                                                   // We'll return an AnyValue wrapping the raw pointer for now.
+                                                   // This relies on the calling context to manage lifetime, which is true for `for-of`.
+                                                   // A better solution might involve passing a shared_ptr to `self` into the prototype getters.
+                                                   // For now, let's assume the object containing the iterator is alive.
+                                                   return AnyValue::from_iterator_ref(self); },
+                                                key);
+            }
+            // --- next() method ---
+            if (key == "next")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                                                AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
+                                                auto res = self->next(val);
+                                                return AnyValue::make_object({{"value",res.value.value_or(AnyValue::make_undefined())},{"done",AnyValue::make_boolean(res.done)},}); },
+                                               key);
+            }
+            // --- toArray() method ---
+            if (key == "toArray")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
+                                               { return AnyValue::make_array(self->to_vector()); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/object.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp
+{
+    namespace ObjectPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsObject *self)
+        {
+            // --- toString() method ---
+            if (key == "toString" )
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

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

@@ -0,0 +1,124 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/promise.hpp"
+#include "any_value.hpp"
+
+namespace jspp {
+    namespace PromisePrototypes {
+        inline std::optional<AnyValue> get(const std::string& key, JsPromise* self) {
+            
+            if (key == "then") {
+                return AnyValue::make_function([self](const AnyValue& thisVal, const std::vector<AnyValue>& args) -> AnyValue {
+                    AnyValue onFulfilled = (args.size() > 0 && args[0].is_function()) ? args[0] : AnyValue::make_undefined();
+                    AnyValue onRejected = (args.size() > 1 && args[1].is_function()) ? args[1] : AnyValue::make_undefined();
+                    
+                    // "then" returns a new Promise
+                    JsPromise newPromise; 
+                    AnyValue newPromiseVal = AnyValue::make_promise(newPromise);
+                    
+                    // Capture shared pointer to the new promise's state to keep it alive and modify it
+                    auto newPromiseState = newPromise.state; 
+                    // Helper wrapper to interact with state
+                    auto resolveNew = [newPromiseState](const AnyValue& v) {
+                        JsPromise p; p.state = newPromiseState;
+                        p.resolve(v);
+                    };
+                    auto rejectNew = [newPromiseState](const AnyValue& r) {
+                        JsPromise p; p.state = newPromiseState;
+                        p.reject(r);
+                    };
+
+
+                    // Resolve handler
+                    auto resolveHandler = [resolveNew, rejectNew, onFulfilled](AnyValue val) mutable {
+                        if (onFulfilled.is_function()) {
+                            try {
+                                auto res = onFulfilled.as_function()->call(AnyValue::make_undefined(), {val});
+                                if (res.is_promise()) {
+                                    // Chaining: newPromise follows res
+                                    auto chained = res.as_promise();
+                                    chained->then(
+                                        [resolveNew](AnyValue v) { resolveNew(v); },
+                                        [rejectNew](AnyValue e) { rejectNew(e); }
+                                    );
+                                } else {
+                                    resolveNew(res);
+                                }
+                            } catch (const Exception& e) {
+                                rejectNew(*e.data);
+                            } catch (...) {
+                                rejectNew(AnyValue::make_string("Unknown error"));
+                            }
+                        } else {
+                            resolveNew(val); // Fallthrough
+                        }
+                    };
+
+                    // Reject handler
+                    auto rejectHandler = [resolveNew, rejectNew, onRejected](AnyValue reason) mutable {
+                         if (onRejected.is_function()) {
+                            try {
+                                auto res = onRejected.as_function()->call(AnyValue::make_undefined(), {reason});
+                                if (res.is_promise()) {
+                                    auto chained = res.as_promise();
+                                    chained->then(
+                                        [resolveNew](AnyValue v) { resolveNew(v); },
+                                        [rejectNew](AnyValue e) { rejectNew(e); }
+                                    );
+                                } else {
+                                    resolveNew(res); // Recovered
+                                }
+                            } catch (const Exception& e) {
+                                rejectNew(*e.data);
+                            } catch (...) {
+                                rejectNew(AnyValue::make_string("Unknown error"));
+                            }
+                        } else {
+                            rejectNew(reason); // Fallthrough
+                        }
+                    };
+
+                    self->then(resolveHandler, rejectHandler);
+                    return newPromiseVal;
+                }, "then");
+            }
+
+            if (key == "catch") {
+                 return AnyValue::make_function([self](const AnyValue& thisVal, const std::vector<AnyValue>& args) -> AnyValue {
+                    // catch(onRejected) is then(undefined, onRejected)
+                    AnyValue onRejected = (args.size() > 0 && args[0].is_function()) ? args[0] : AnyValue::make_undefined();
+                    return thisVal.get_own_property("then").as_function()->call(thisVal, {AnyValue::make_undefined(), onRejected});
+                 }, "catch");
+            }
+
+            if (key == "finally") {
+                return AnyValue::make_function([self](const AnyValue& thisVal, const std::vector<AnyValue>& args) -> AnyValue {
+                    AnyValue onFinally = (args.size() > 0 && args[0].is_function()) ? args[0] : AnyValue::make_undefined();
+                    
+                    // finally(onFinally) returns a promise that passes through value/reason, 
+                    // but executes onFinally first.
+                    
+                    return thisVal.get_own_property("then").as_function()->call(thisVal, {
+                        AnyValue::make_function([onFinally](const AnyValue&, const std::vector<AnyValue>& args) -> AnyValue {
+                            AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
+                            if (onFinally.is_function()) {
+                                onFinally.as_function()->call(AnyValue::make_undefined(), {});
+                            }
+                            return val;
+                        }, ""),
+                        AnyValue::make_function([onFinally](const AnyValue&, const std::vector<AnyValue>& args) -> AnyValue {
+                            AnyValue reason = args.empty() ? AnyValue::make_undefined() : args[0];
+                            if (onFinally.is_function()) {
+                                onFinally.as_function()->call(AnyValue::make_undefined(), {});
+                            }
+                            throw Exception(reason);
+                        }, "")
+                    });
+                }, "finally");
+            }
+            
+            return std::nullopt;
+        }
+    }
+}