@ugo-studio/jspp 0.1.3 → 0.1.5

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

@@ -11,12 +11,14 @@ std::string jspp::JsIterator<T>::to_std_string() const
 }
 
 template <typename T>
-jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::next()
+jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::next(const T &val)
 {
     // If the generator is already finished or invalid, return {undefined, true}
     if (!handle || handle.done())
         return {std::nullopt, true};
 
+    handle.promise().input_value = val;
+
     // Resume execution until next co_yield or co_return
     handle.resume();
 
@@ -33,9 +35,9 @@ jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::next()
 }
 
 template <typename T>
-std::vector<std::optional<T>> jspp::JsIterator<T>::to_vector()
+std::vector<T> jspp::JsIterator<T>::to_vector()
 {
-    std::vector<std::optional<AnyValue>> result;
+    std::vector<T> result;
     while (true)
     {
         auto next = this->next();
@@ -43,13 +45,13 @@ std::vector<std::optional<T>> jspp::JsIterator<T>::to_vector()
         {
             break;
         }
-        result.push_back(next.value);
+        result.push_back(next.value.value_or(AnyValue::make_undefined()));
     }
     return result;
 }
 
 template <typename T>
-jspp::AnyValue jspp::JsIterator<T>::get_property(const std::string &key)
+jspp::AnyValue jspp::JsIterator<T>::get_property(const std::string &key, const AnyValue &thisVal)
 {
     auto it = props.find(key);
     if (it == props.end())
@@ -60,18 +62,18 @@ jspp::AnyValue jspp::JsIterator<T>::get_property(const std::string &key)
             auto proto_it = IteratorPrototypes::get(key, this);
             if (proto_it.has_value())
             {
-                return AnyValue::resolve_property_for_read(proto_it.value());
+                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
             }
         }
         // prototype not found
         return jspp::AnyValue::make_undefined();
     }
 
-    return jspp::AnyValue::resolve_property_for_read(it->second);
+    return jspp::AnyValue::resolve_property_for_read(it->second, thisVal, key);
 }
 
 template <typename T>
-jspp::AnyValue jspp::JsIterator<T>::set_property(const std::string &key, const AnyValue &value)
+jspp::AnyValue jspp::JsIterator<T>::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
 {
     // set prototype property if accessor descriptor
     if constexpr (std::is_same_v<T, AnyValue>)
@@ -82,7 +84,11 @@ jspp::AnyValue jspp::JsIterator<T>::set_property(const std::string &key, const A
             auto proto_value = proto_it.value();
             if (proto_value.is_accessor_descriptor())
             {
-                return AnyValue::resolve_property_for_write(proto_it.value(), value);
+                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+            }
+            if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable)
+            {
+                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
             }
         }
     }
@@ -91,7 +97,7 @@ jspp::AnyValue jspp::JsIterator<T>::set_property(const std::string &key, const A
     auto it = props.find(key);
     if (it != props.end())
     {
-        return jspp::AnyValue::resolve_property_for_write(it->second, value);
+        return jspp::AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
     }
     else
     {

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

@@ -4,31 +4,106 @@
 #include "values/object.hpp"
 #include "any_value.hpp"
 
+namespace jspp {
+    JsObject::JsObject() : shape(Shape::empty_shape()), proto(nullptr) {}
+
+    JsObject::JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, std::shared_ptr<AnyValue> pr) : proto(pr) {
+        shape = Shape::empty_shape();
+        storage.reserve(p.size());
+        for (const auto& pair : p) {
+            shape = shape->transition(pair.first);
+            storage.push_back(pair.second);
+        }
+    }
+
+    JsObject::JsObject(const std::map<std::string, AnyValue> &p, std::shared_ptr<AnyValue> pr) : proto(pr) {
+        shape = Shape::empty_shape();
+        storage.reserve(p.size());
+        for (const auto& pair : p) {
+            shape = shape->transition(pair.first);
+            storage.push_back(pair.second);
+        }
+    }
+}
+
 std::string jspp::JsObject::to_std_string() const
 {
     return "[Object Object]";
 }
 
-jspp::AnyValue jspp::JsObject::get_property(const std::string &key)
+bool jspp::JsObject::has_property(const std::string &key) const
+{
+    if (deleted_keys.count(key)) return false;
+
+    if (shape->get_offset(key).has_value())
+        return true;
+    if (proto && !(*proto).is_null() && !(*proto).is_undefined())
+    {
+        if ((*proto).has_property(key))
+            return true;
+    }
+    if (ObjectPrototypes::get(key, const_cast<JsObject *>(this)).has_value())
+        return true;
+    return false;
+}
+
+jspp::AnyValue jspp::JsObject::get_property(const std::string &key, const AnyValue &thisVal)
 {
-    auto it = props.find(key);
-    if (it != props.end())
+    if (deleted_keys.count(key)) return AnyValue::make_undefined();
+
+    auto offset = shape->get_offset(key);
+    if (!offset.has_value())
     {
-        return jspp::AnyValue::resolve_property_for_read(it->second);
+        // check prototype chain
+        if (proto && !(*proto).is_null() && !(*proto).is_undefined())
+        {
+            if ((*proto).has_property(key))
+            {
+                return (*proto).get_property_with_receiver(key, thisVal);
+            }
+        }
+
+        // check built-in prototype methods (Object.prototype)
+        auto proto_it = ObjectPrototypes::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();
     }
-    return jspp::AnyValue::make_undefined();
+    return AnyValue::resolve_property_for_read(storage[offset.value()], thisVal, key);
 }
 
-jspp::AnyValue jspp::JsObject::set_property(const std::string &key, const AnyValue &value)
+jspp::AnyValue jspp::JsObject::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
 {
-    auto it = props.find(key);
-    if (it != props.end())
+    // set prototype property if accessor descriptor
+    auto proto_it = ObjectPrototypes::get(key, this);
+    if (proto_it.has_value())
+    {
+        auto proto_value = proto_it.value();
+        if (proto_value.is_accessor_descriptor())
+        {
+            return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+        }
+        if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable)
+        {
+            return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+        }
+    }
+
+    // set own property
+    if (deleted_keys.count(key)) deleted_keys.erase(key);
+
+    auto offset = shape->get_offset(key);
+    if (offset.has_value())
     {
-        return jspp::AnyValue::resolve_property_for_write(it->second, value);
+        return AnyValue::resolve_property_for_write(storage[offset.value()], thisVal, value, key);
     }
     else
     {
-        props[key] = value;
+        shape = shape->transition(key);
+        storage.push_back(value);
         return value;
     }
 }

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

@@ -0,0 +1,181 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/promise.hpp"
+#include "any_value.hpp"
+#include "values/prototypes/promise.hpp"
+
+namespace jspp {
+
+    inline PromiseState::PromiseState() : result(std::make_shared<AnyValue>(AnyValue::make_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;
+        }
+
+        state->status = PromiseStatus::Fulfilled;
+        *(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);
+            });
+        }
+    }
+
+    inline void JsPromise::reject(const AnyValue& reason) {
+        if (state->status != PromiseStatus::Pending) return;
+        state->status = PromiseStatus::Rejected;
+        *(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);
+            });
+        }
+    }
+
+    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 (onFulfilled) state->onFulfilled.push_back(onFulfilled);
+            if (onRejected) state->onRejected.push_back(onRejected);
+        }
+    }
+
+    inline std::string JsPromise::to_std_string() const {
+        return "[object Promise]";
+    }
+
+    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 it = props.find(key);
+        if (it != props.end()) {
+             return AnyValue::resolve_property_for_read(it->second, thisVal, key);
+        }
+        return AnyValue::make_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;
+         }
+    }
+    
+    // --- Coroutine Methods ---
+    
+    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 auto JsPromisePromiseType::await_transform(const AnyValue& value) {
+         return AnyValueAwaiter{value};
+    }
+
+    // --- AnyValueAwaiter ---
+
+    inline bool AnyValueAwaiter::await_ready() {
+        if (!value.is_promise()) return true; // Non-promise values are ready immediately (for now)
+        // Always suspend for promises to ensure microtask interleaving, even if already resolved.
+        return false;
+    }
+
+    inline void AnyValueAwaiter::await_suspend(std::coroutine_handle<> h) {
+        if (!value.is_promise()) {
+            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(); } 
+        );
+    }
+
+    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));
+        }
+    }
+
+}

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

@@ -3,7 +3,7 @@
 #include "types.hpp"
 #include "values/array.hpp"
 #include "values/string.hpp"
-#include "error.hpp"
+#include "exception.hpp"
 #include "any_value.hpp"
 #include "values/prototypes/string.hpp"
 
@@ -22,13 +22,13 @@ jspp::JsIterator<jspp::AnyValue> jspp::JsString::get_iterator()
     co_return AnyValue::make_undefined();
 }
 
-jspp::AnyValue jspp::JsString::get_property(const std::string &key)
+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());
+        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))

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

@@ -10,13 +10,13 @@ std::string jspp::JsSymbol::to_std_string() const
     return "Symbol(" + description + ")";
 }
 
-jspp::AnyValue jspp::JsSymbol::get_property(const std::string &key)
+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());
+        return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
     }
     // not found
     return AnyValue::make_undefined();

package/src/prelude/values/iterator.hpp

@@ -25,6 +25,7 @@ namespace jspp
         {
             std::optional<T> current_value;
             std::exception_ptr exception_;
+            T input_value;
 
             JsIterator get_return_object()
             {
@@ -40,10 +41,17 @@ namespace jspp
 
             // Handle co_yield
             template <typename From>
-            std::suspend_always yield_value(From &&from)
+            auto yield_value(From &&from)
             {
                 current_value = std::forward<From>(from);
-                return {};
+                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
@@ -80,9 +88,9 @@ namespace jspp
         std::unordered_map<std::string, AnyValue> props;
 
         std::string to_std_string() const;
-        NextResult next();
-        std::vector<std::optional<T>> to_vector();
-        AnyValue get_property(const std::string &key);
-        AnyValue set_property(const std::string &key, const AnyValue &value);
+        NextResult next(const T &val = T());
+        std::vector<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

@@ -1,6 +1,9 @@
 #pragma once
 
 #include "types.hpp"
+#include "shape.hpp"
+#include <vector>
+#include <unordered_set>
 
 namespace jspp
 {
@@ -9,10 +12,18 @@ namespace jspp
 
     struct JsObject
     {
-        std::map<std::string, AnyValue> props;
+        std::shared_ptr<Shape> shape;
+        std::vector<AnyValue> storage;
+        std::shared_ptr<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);
 
         std::string to_std_string() const;
-        AnyValue get_property(const std::string &key);
-        AnyValue set_property(const std::string &key, const AnyValue &value);
+        bool has_property(const std::string &key) const;
+        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(const AnyValue&)>> onFulfilled;
+        std::vector<std::function<void(const 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(const AnyValue&)> onFulfilled, std::function<void(const 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();
+    };
+}