@ugo-studio/jspp 0.1.3 → 0.1.4

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

@@ -1,77 +1,125 @@
-#pragma once
-
-#include <variant>
-
-#include "types.hpp"
-#include "values/function.hpp"
-#include "any_value.hpp"
-#include "values/prototypes/function.hpp"
-
-std::string jspp::JsFunction::to_std_string() const
-{
-    if (is_generator)
-    {
-        return "function* " + name + "() { [native code] }";
-    }
-    return "function " + name + "() { [native code] }";
-}
-
-jspp::AnyValue jspp::JsFunction::call(const std::vector<AnyValue> &args)
-{
-
-    if (std::function<AnyValue(const std::vector<AnyValue> &)> *func = std::get_if<0>(&callable))
-    {
-        return (*func)(args);
-    }
-    else if (std::function<jspp::JsIterator<jspp::AnyValue>(const std::vector<jspp::AnyValue> &)> *func = std::get_if<1>(&callable))
-    {
-        return AnyValue::from_iterator((*func)(args));
-    }
-    else
-    {
-        return AnyValue::make_undefined();
-    }
-}
-
-jspp::AnyValue jspp::JsFunction::get_property(const std::string &key)
-{
-    auto it = props.find(key);
-    if (it == props.end())
-    {
-        // check prototype
-        auto proto_it = FunctionPrototypes::get(key, this);
-        if (proto_it.has_value())
-        {
-            return AnyValue::resolve_property_for_read(proto_it.value());
-        }
-        // not found
-        return AnyValue::make_undefined();
-    }
-    return AnyValue::resolve_property_for_read(it->second);
-}
-
-jspp::AnyValue jspp::JsFunction::set_property(const std::string &key, const AnyValue &value)
-{
-    // set prototype property if accessor descriptor
-    auto proto_it = FunctionPrototypes::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, value);
-        }
-    }
-
-    // set own property
-    auto it = props.find(key);
-    if (it != props.end())
-    {
-        return AnyValue::resolve_property_for_write(it->second, value);
-    }
-    else
-    {
-        props[key] = value;
-        return value;
-    }
-}
+#pragma once
+
+#include <variant>
+
+#include "types.hpp"
+#include "values/function.hpp"
+#include "any_value.hpp"
+#include "values/prototypes/function.hpp"
+
+std::string jspp::JsFunction::to_std_string() const
+{
+    if (is_async) {
+        return "async function " + name + "() { [native code] }";
+    }
+    if (is_generator)
+    {
+        return "function* " + name + "() { [native code] }";
+    }
+    return "function " + name + "() { [native code] }";
+}
+
+jspp::AnyValue jspp::JsFunction::call(const AnyValue &thisVal, const std::vector<AnyValue> &args)
+{
+    if (std::function<AnyValue(const AnyValue &, const std::vector<AnyValue> &)> *func = std::get_if<0>(&callable))
+    {
+        return (*func)(thisVal, args);
+    }
+    else if (std::function<jspp::JsIterator<jspp::AnyValue>(const AnyValue &, const std::vector<jspp::AnyValue> &)> *func = std::get_if<1>(&callable))
+    {
+        return AnyValue::from_iterator((*func)(thisVal, args));
+    }
+    else if (std::function<jspp::JsPromise(const AnyValue &, const std::vector<jspp::AnyValue> &)> *func = std::get_if<2>(&callable))
+    {
+        return AnyValue::make_promise((*func)(thisVal, args));
+    }
+    else
+    {
+        return AnyValue::make_undefined();
+    }
+}
+
+jspp::AnyValue jspp::JsFunction::get_property(const std::string &key, const AnyValue &thisVal)
+{
+    auto it = props.find(key);
+    if (it == props.end())
+    {
+        // check explicit proto chain (e.g. for classes extending other classes)
+        if (proto && !(*proto).is_null() && !(*proto).is_undefined())
+        {
+            return (*proto).get_property_with_receiver(key, thisVal);
+        }
+
+        // check prototype (implicit Function.prototype)
+        auto proto_it = FunctionPrototypes::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 AnyValue::resolve_property_for_read(it->second, thisVal, key);
+}
+
+jspp::AnyValue jspp::JsFunction::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+{
+    // set prototype property if accessor descriptor
+    auto proto_it = FunctionPrototypes::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
+    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;
+    }
+}
+
+// AnyValue::construct implementation
+const jspp::AnyValue jspp::AnyValue::construct(const std::vector<AnyValue> &args) const
+{
+    if (!is_function())
+    {
+        throw Exception::make_exception(to_std_string() + " is not a constructor", "TypeError");
+    }
+
+    // 1. Get prototype
+    AnyValue proto = get_own_property("prototype");
+    // If prototype is not an object, default to a plain object (which ideally inherits from Object.prototype)
+    // Here we just make a plain object.
+    if (!proto.is_object())
+    {
+        proto = AnyValue::make_object({});
+    }
+
+    // 2. Create instance
+    AnyValue instance = AnyValue::make_object_with_proto({}, proto);
+
+    // 3. Call function
+    // We pass 'instance' as 'this'
+    AnyValue result = as_function()->call(instance, args);
+
+    // 4. Return result if object, else instance
+    if (result.is_object() || result.is_function() || result.is_array() || result.is_promise())
+    {
+        return result;
+    }
+    return instance;
+}

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();
 
@@ -49,7 +51,7 @@ std::vector<std::optional<T>> jspp::JsIterator<T>::to_vector()
 }
 
 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

@@ -9,22 +9,52 @@ std::string jspp::JsObject::to_std_string() const
     return "[Object Object]";
 }
 
-jspp::AnyValue jspp::JsObject::get_property(const std::string &key)
+jspp::AnyValue jspp::JsObject::get_property(const std::string &key, const AnyValue &thisVal)
 {
     auto it = props.find(key);
-    if (it != props.end())
+    if (it == props.end())
     {
-        return jspp::AnyValue::resolve_property_for_read(it->second);
+        // check prototype chain
+        if (proto && !(*proto).is_null() && !(*proto).is_undefined())
+        {
+            return (*proto).get_property_with_receiver(key, thisVal);
+        }
+
+        // check built-in prototype methods (Object.prototype)
+        // ideally these should be on the root prototype object, but for now we keep this fallback
+        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(it->second, 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)
 {
+    // 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
     auto it = props.find(key);
     if (it != props.end())
     {
-        return jspp::AnyValue::resolve_property_for_write(it->second, value);
+        return AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
     }
     else
     {

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](AnyValue v) {
+                     if (auto s = weak_state.lock()) {
+                         JsPromise localP; localP.state = s;
+                         localP.resolve(v); 
+                     }
+                 },
+                 [weak_state](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(AnyValue)> onFulfilled, std::function<void(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();
+        NextResult next(const T &val = T());
         std::vector<std::optional<T>> to_vector();
-        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/object.hpp

@@ -10,9 +10,13 @@ namespace jspp
     struct JsObject
     {
         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);
     };
 }