@ugo-studio/jspp 0.1.9 → 0.2.1

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

@@ -5,184 +5,250 @@
 #include "any_value.hpp"
 #include "values/prototypes/promise.hpp"
 
-namespace jspp {
+namespace jspp
+{
 
-    inline PromiseState::PromiseState() : result(std::make_shared<AnyValue>(AnyValue::make_undefined())) {}
+    inline PromiseState::PromiseState() : result(Constants::UNDEFINED) {}
 
     inline JsPromise::JsPromise() : state(std::make_shared<PromiseState>()) {}
 
-    inline void JsPromise::resolve(const AnyValue& value) {
-        if (state->status != PromiseStatus::Pending) return;
-
-        if (value.is_promise()) {
-             auto p = value.as_promise();
-             if (p->state == state) {
-                 reject(AnyValue::make_string("TypeError: Chaining cycle detected for promise"));
-                 return;
-             }
-             
-             auto weak_state = std::weak_ptr<PromiseState>(state);
-             
-             p->then(
-                 [weak_state](const AnyValue& v) {
-                     if (auto s = weak_state.lock()) {
-                         JsPromise localP; localP.state = s;
-                         localP.resolve(v); 
-                     }
-                 },
-                 [weak_state](const AnyValue& r) {
-                     if (auto s = weak_state.lock()) {
-                         JsPromise localP; localP.state = s;
-                         localP.reject(r);
-                     }
-                 }
-             );
-             return;
+    inline void JsPromise::resolve(const AnyValue &value)
+    {
+        if (state->status != PromiseStatus::Pending)
+            return;
+
+        if (value.is_promise())
+        {
+            auto p = value.as_promise();
+            if (p->state == state)
+            {
+                reject(AnyValue::make_string("TypeError: Chaining cycle detected for promise"));
+                return;
+            }
+
+            auto weak_state = std::weak_ptr<PromiseState>(state);
+
+            p->then(
+                [weak_state](const AnyValue &v)
+                {
+                    if (auto s = weak_state.lock())
+                    {
+                        // We can't easily use JsPromise here because it's a HeapObject now.
+                        // But we can manually resolve the state if we have a way.
+                        // Actually, we can create a temporary AnyValue from the state.
+                        // But AnyValue expects a JsPromise* which was allocated with new.
+                        // This is tricky.
+                        // Let's assume we can just modify the status and result of the state directly.
+                        s->status = PromiseStatus::Fulfilled;
+                        s->result = v;
+                        auto callbacks = s->onFulfilled;
+                        s->onFulfilled.clear();
+                        s->onRejected.clear();
+                        for (auto &cb : callbacks)
+                            jspp::Scheduler::instance().enqueue([cb, v]()
+                                                                { cb(v); });
+                    }
+                },
+                [weak_state](const AnyValue &r)
+                {
+                    if (auto s = weak_state.lock())
+                    {
+                        s->status = PromiseStatus::Rejected;
+                        s->result = r;
+                        auto callbacks = s->onRejected;
+                        s->onFulfilled.clear();
+                        s->onRejected.clear();
+                        for (auto &cb : callbacks)
+                            jspp::Scheduler::instance().enqueue([cb, r]()
+                                                                { cb(r); });
+                    }
+                });
+            return;
         }
 
         state->status = PromiseStatus::Fulfilled;
-        *(state->result) = value;
-        
+        state->result = value;
+
         // Schedule callbacks
         auto callbacks = state->onFulfilled;
         state->onFulfilled.clear();
         state->onRejected.clear();
-        
-        for (auto& cb : callbacks) {
-            jspp::Scheduler::instance().enqueue([cb, value]() {
-                cb(value);
-            });
+
+        for (auto &cb : callbacks)
+        {
+            jspp::Scheduler::instance().enqueue([cb, value]()
+                                                { cb(value); });
         }
     }
 
-    inline void JsPromise::reject(const AnyValue& reason) {
-        if (state->status != PromiseStatus::Pending) return;
+    inline void JsPromise::reject(const AnyValue &reason)
+    {
+        if (state->status != PromiseStatus::Pending)
+            return;
         state->status = PromiseStatus::Rejected;
-        *(state->result) = reason;
-        
+        state->result = reason;
+
         auto callbacks = state->onRejected;
         state->onFulfilled.clear();
         state->onRejected.clear();
-        
-        for (auto& cb : callbacks) {
-            jspp::Scheduler::instance().enqueue([cb, reason]() {
-                cb(reason);
-            });
+
+        for (auto &cb : callbacks)
+        {
+            jspp::Scheduler::instance().enqueue([cb, reason]()
+                                                { cb(reason); });
         }
     }
 
-    inline void JsPromise::then(std::function<void(const AnyValue&)> onFulfilled, std::function<void(const AnyValue&)> onRejected) {
-        if (state->status == PromiseStatus::Fulfilled) {
-            if (onFulfilled) {
-                AnyValue val = *(state->result);
-                jspp::Scheduler::instance().enqueue([onFulfilled, val]() {
-                    onFulfilled(val);
-                });
+    inline void JsPromise::then(std::function<void(const AnyValue &)> onFulfilled, std::function<void(const AnyValue &)> onRejected)
+    {
+        if (state->status == PromiseStatus::Fulfilled)
+        {
+            if (onFulfilled)
+            {
+                AnyValue val = state->result;
+                jspp::Scheduler::instance().enqueue([onFulfilled, val]()
+                                                    { onFulfilled(val); });
             }
-        } else if (state->status == PromiseStatus::Rejected) {
-            if (onRejected) {
-                AnyValue val = *(state->result);
-                jspp::Scheduler::instance().enqueue([onRejected, val]() {
-                    onRejected(val);
-                });
+        }
+        else if (state->status == PromiseStatus::Rejected)
+        {
+            if (onRejected)
+            {
+                AnyValue val = state->result;
+                jspp::Scheduler::instance().enqueue([onRejected, val]()
+                                                    { onRejected(val); });
             }
-        } else {
-            if (onFulfilled) state->onFulfilled.push_back(onFulfilled);
-            if (onRejected) state->onRejected.push_back(onRejected);
+        }
+        else
+        {
+            if (onFulfilled)
+                state->onFulfilled.push_back(onFulfilled);
+            if (onRejected)
+                state->onRejected.push_back(onRejected);
         }
     }
 
-    inline auto JsPromise::operator co_await() const {
+    inline auto JsPromise::operator co_await() const
+    {
+        // This is safe because AnyValue::make_promise copies the JsPromise (which is a HeapObject)
+        // Actually, AnyValue::make_promise(const JsPromise&) does from_ptr(new JsPromise(promise)).
         return AnyValueAwaiter{AnyValue::make_promise(*this)};
     }
 
-    inline std::string JsPromise::to_std_string() const {
+    inline std::string JsPromise::to_std_string() const
+    {
         return "[object Promise]";
     }
 
-    inline AnyValue JsPromise::get_property(const std::string& key, const AnyValue& thisVal) {
+    inline AnyValue JsPromise::get_property(const std::string &key, const AnyValue &thisVal)
+    {
         // Prototype lookup
-        auto proto_it = PromisePrototypes::get(key, const_cast<JsPromise*>(this));
-        if (proto_it.has_value()) {
-             return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+        auto proto_it = PromisePrototypes::get(key, const_cast<JsPromise *>(this));
+        if (proto_it.has_value())
+        {
+            return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
         }
-        
+
         auto it = props.find(key);
-        if (it != props.end()) {
-             return AnyValue::resolve_property_for_read(it->second, thisVal, key);
+        if (it != props.end())
+        {
+            return AnyValue::resolve_property_for_read(it->second, thisVal, key);
         }
-        return AnyValue::make_undefined();
+        return Constants::UNDEFINED;
     }
 
-    inline AnyValue JsPromise::set_property(const std::string& key, const AnyValue& value, const AnyValue& thisVal) {
-         // Prototype check (if we had setters on prototype)
-         
-         auto it = props.find(key);
-         if (it != props.end()) {
-             return AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
-         } else {
-             props[key] = value;
-             return value;
-         }
+    inline AnyValue JsPromise::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+    {
+        auto it = props.find(key);
+        if (it != props.end())
+        {
+            return AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
+        }
+        else
+        {
+            props[key] = value;
+            return value;
+        }
     }
-    
+
     // --- Coroutine Methods ---
-    
-    inline void JsPromisePromiseType::return_value(const AnyValue& val) {
+
+    inline void JsPromisePromiseType::return_value(const AnyValue &val)
+    {
         promise.resolve(val);
     }
-    
-    inline void JsPromisePromiseType::unhandled_exception() {
-         try {
-             throw;
-         } catch (const Exception& e) {
-             promise.reject(*(e.data));
-         } catch (const std::exception& e) {
-             promise.reject(AnyValue::make_string(e.what()));
-         } catch (...) {
-             promise.reject(AnyValue::make_string("Unknown exception"));
-         }
+
+    inline void JsPromisePromiseType::unhandled_exception()
+    {
+        try
+        {
+            throw;
+        }
+        catch (const Exception &e)
+        {
+            promise.reject(e.data);
+        }
+        catch (const std::exception &e)
+        {
+            promise.reject(AnyValue::make_string(e.what()));
+        }
+        catch (...)
+        {
+            promise.reject(AnyValue::make_string("Unknown exception"));
+        }
     }
-    
-    inline auto JsPromisePromiseType::await_transform(const AnyValue& value) {
-         return AnyValueAwaiter{value};
+
+    inline auto JsPromisePromiseType::await_transform(const AnyValue &value)
+    {
+        return AnyValueAwaiter{value};
     }
 
-    inline auto JsPromisePromiseType::await_transform(const JsPromise& value) {
-         return AnyValueAwaiter{AnyValue::make_promise(value)};
+    inline auto JsPromisePromiseType::await_transform(const JsPromise &value)
+    {
+        // value is a JsPromise& which is a HeapObject.
+        // We wrap it in a temporary AnyValue for Awaiter.
+        // Wait, AnyValue::make_promise(value) will allocate a new JsPromise on heap.
+        // This is fine for now.
+        return AnyValueAwaiter{AnyValue::make_promise(value)};
     }
 
     // --- AnyValueAwaiter ---
 
-    inline bool AnyValueAwaiter::await_ready() {
-        // Always suspend to ensure microtask interleaving, even if already resolved or not a promise.
+    inline bool AnyValueAwaiter::await_ready()
+    {
         return false;
     }
 
-    inline void AnyValueAwaiter::await_suspend(std::coroutine_handle<> h) {
-        if (!value.is_promise()) {
-            jspp::Scheduler::instance().enqueue([h]() mutable { h.resume(); });
+    inline void AnyValueAwaiter::await_suspend(std::coroutine_handle<> h)
+    {
+        if (!value.is_promise())
+        {
+            jspp::Scheduler::instance().enqueue([h]() mutable
+                                                { h.resume(); });
             return;
         }
         auto p = value.as_promise();
-        
-        // Attach resume to promise resolution.
-        // Since we are using the Scheduler in .then(), this will be queued.
+
         p->then(
-            [h](AnyValue v) mutable { h.resume(); },
-            [h](AnyValue e) mutable { h.resume(); } 
-        );
+            [h](AnyValue v) mutable
+            { h.resume(); },
+            [h](AnyValue e) mutable
+            { h.resume(); });
     }
 
-    inline AnyValue AnyValueAwaiter::await_resume() {
-        if (!value.is_promise()) return value;
+    inline AnyValue AnyValueAwaiter::await_resume()
+    {
+        if (!value.is_promise())
+            return value;
         auto p = value.as_promise();
-        if (p->state->status == PromiseStatus::Fulfilled) {
-            return *(p->state->result);
-        } else {
-            // Throw exception to be caught by try/catch in coroutine
-            throw Exception(*(p->state->result));
+        if (p->state->status == PromiseStatus::Fulfilled)
+        {
+            return p->state->result;
+        }
+        else
+        {
+            throw Exception(p->state->result);
         }
     }
 
-}
+}

package/src/prelude/values/helpers/string.hpp

@@ -7,12 +7,12 @@
 #include "any_value.hpp"
 #include "values/prototypes/string.hpp"
 
-std::string jspp::JsString::to_std_string() const
+inline std::string jspp::JsString::to_std_string() const
 {
     return value;
 }
 
-jspp::JsIterator<jspp::AnyValue> jspp::JsString::get_iterator()
+inline jspp::JsIterator<jspp::AnyValue> jspp::JsString::get_iterator()
 {
     size_t strLength = value.length();
     for (size_t idx = 0; idx < strLength; idx++)
@@ -22,29 +22,26 @@ jspp::JsIterator<jspp::AnyValue> jspp::JsString::get_iterator()
     co_return AnyValue::make_undefined();
 }
 
-jspp::AnyValue jspp::JsString::get_property(const std::string &key, const AnyValue &thisVal)
+inline jspp::AnyValue jspp::JsString::get_property(const std::string &key, const AnyValue &thisVal)
 {
-    // Check for prototype methods
     auto proto_fn = StringPrototypes::get(key, this);
     if (proto_fn.has_value())
     {
         return AnyValue::resolve_property_for_read(proto_fn.value(), thisVal, key);
     }
-    // Handle character access by string index (e.g., "abc"["1"])
     if (JsArray::is_array_index(key))
     {
         uint32_t idx = static_cast<uint32_t>(std::stoull(key));
         return get_property(idx);
     }
-    // not found
-    return AnyValue::make_undefined();
+    return Constants::UNDEFINED;
 }
 
-jspp::AnyValue jspp::JsString::get_property(uint32_t idx)
+inline jspp::AnyValue jspp::JsString::get_property(uint32_t idx)
 {
     if (idx < value.length())
     {
         return AnyValue::make_string(std::string(1, value[idx]));
     }
-    return AnyValue::make_undefined();
-}
+    return Constants::UNDEFINED;
+}

package/src/prelude/values/helpers/symbol.hpp

@@ -1,23 +1,21 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/symbol.hpp"
-#include "any_value.hpp"
-#include "values/prototypes/symbol.hpp"
-
-std::string jspp::JsSymbol::to_std_string() const
-{
-    return "Symbol(" + description + ")";
-}
-
-jspp::AnyValue jspp::JsSymbol::get_property(const std::string &key, const AnyValue &thisVal)
-{
-    // check prototype
-    auto proto_it = SymbolPrototypes::get(key, this);
-    if (proto_it.has_value())
-    {
-        return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
-    }
-    // not found
-    return AnyValue::make_undefined();
-}
+#pragma once
+
+#include "types.hpp"
+#include "values/symbol.hpp"
+#include "any_value.hpp"
+#include "values/prototypes/symbol.hpp"
+
+inline std::string jspp::JsSymbol::to_std_string() const
+{
+    return "Symbol(" + description + ")";
+}
+
+inline jspp::AnyValue jspp::JsSymbol::get_property(const std::string &key, const AnyValue &thisVal)
+{
+    auto proto_it = SymbolPrototypes::get(key, this);
+    if (proto_it.has_value())
+    {
+        return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+    }
+    return Constants::UNDEFINED;
+}

package/src/prelude/values/iterator.hpp

@@ -13,7 +13,7 @@ namespace jspp
     class AnyValue;
 
     template <typename T>
-    class JsIterator
+    class JsIterator : public HeapObject
     {
     public:
         struct NextResult
@@ -21,6 +21,9 @@ namespace jspp
             std::optional<T> value;
             bool done;
         };
+
+        JsType get_heap_type() const override { return JsType::Iterator; }
+
         struct promise_type
         {
             std::optional<T> current_value;

package/src/prelude/values/object.hpp

@@ -10,16 +10,18 @@ namespace jspp
     // Forward declaration of AnyValue
     class AnyValue;
 
-    struct JsObject
+    struct JsObject : HeapObject
     {
         std::shared_ptr<Shape> shape;
         std::vector<AnyValue> storage;
-        std::shared_ptr<AnyValue> proto;
+        AnyValue proto;
         std::unordered_set<std::string> deleted_keys;
 
         JsObject();
-        JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, std::shared_ptr<AnyValue> pr = nullptr);
-        JsObject(const std::map<std::string, AnyValue> &p, std::shared_ptr<AnyValue> pr = nullptr);
+        JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, AnyValue pr);
+        JsObject(const std::map<std::string, AnyValue> &p, AnyValue pr);
+
+        JsType get_heap_type() const override { return JsType::Object; }
 
         std::string to_std_string() const;
         bool has_property(const std::string &key) const;

package/src/prelude/values/promise.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "types.hpp"
+#include "any_value.hpp"
 #include <vector>
 #include <functional>
 #include <memory>
@@ -19,7 +20,7 @@ namespace jspp
     struct PromiseState
     {
         PromiseStatus status = PromiseStatus::Pending;
-        std::shared_ptr<AnyValue> result; // Value if fulfilled, reason if rejected
+        AnyValue result; // Value if fulfilled, reason if rejected
         std::vector<std::function<void(const AnyValue&)>> onFulfilled;
         std::vector<std::function<void(const AnyValue&)>> onRejected;
         
@@ -28,7 +29,7 @@ namespace jspp
 
     struct JsPromisePromiseType; // Forward declaration
 
-    struct JsPromise
+    struct JsPromise : HeapObject
     {
         using promise_type = JsPromisePromiseType;
 
@@ -37,6 +38,8 @@ namespace jspp
 
         JsPromise();
 
+        JsType get_heap_type() const override { return JsType::Promise; }
+
         // --- Promise Logic ---
         void resolve(const AnyValue& value);
         void reject(const AnyValue& reason);