@ugo-studio/jspp 0.1.2 → 0.1.4

package/src/prelude/values/{operators → helpers}/array.hpp

@@ -2,7 +2,7 @@
 
 #include "types.hpp"
 #include "values/array.hpp"
-#include "error.hpp"
+#include "exception.hpp"
 #include "any_value.hpp"
 #include "values/prototypes/array.hpp"
 
@@ -47,7 +47,17 @@ std::string jspp::JsArray::to_std_string() const
     return result;
 }
 
-jspp::AnyValue jspp::JsArray::get_property(const std::string &key)
+jspp::JsIterator<jspp::AnyValue> jspp::JsArray::get_iterator()
+{
+    for (uint64_t idx = 0; idx < length; ++idx)
+    {
+        co_yield get_property(static_cast<uint32_t>(idx));
+    }
+
+    co_return AnyValue::make_undefined();
+}
+
+jspp::AnyValue jspp::JsArray::get_property(const std::string &key, const AnyValue &thisVal)
 {
     if (
         !key.empty() && std::isdigit(static_cast<unsigned char>(key[0])) // Quick check: if the first character is not a digit, it can't be a standard index.
@@ -65,12 +75,12 @@ jspp::AnyValue jspp::JsArray::get_property(const std::string &key)
             auto proto_it = ArrayPrototypes::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();
         }
-        return AnyValue::resolve_property_for_read(it->second);
+        return AnyValue::resolve_property_for_read(it->second, thisVal, key);
     }
 }
 
@@ -78,17 +88,17 @@ jspp::AnyValue jspp::JsArray::get_property(uint32_t idx)
 {
     if (idx < dense.size())
     {
-        return AnyValue::resolve_property_for_read(dense[idx].value_or(AnyValue::make_undefined()));
+        return dense[idx].value_or(AnyValue::make_undefined());
     }
     const auto &it = sparse.find(idx);
     if (it != sparse.end())
     {
-        return AnyValue::resolve_property_for_read(it->second.value_or(AnyValue::make_undefined()));
+        return it->second.value_or(AnyValue::make_undefined());
     }
     return AnyValue::make_undefined();
 }
 
-jspp::AnyValue jspp::JsArray::set_property(const std::string &key, const AnyValue &value)
+jspp::AnyValue jspp::JsArray::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
 {
     if (
         !key.empty() && std::isdigit(static_cast<unsigned char>(key[0])) // Quick check: if the first character is not a digit, it can't be a standard index.
@@ -100,13 +110,17 @@ jspp::AnyValue jspp::JsArray::set_property(const std::string &key, const AnyValu
     else
     {
         // set prototype property if accessor descriptor
-        auto proto_it = ArrayPrototypes::get(key, this);
-        if (proto_it.has_value())
+        auto proto_val_opt = ArrayPrototypes::get(key, this);
+        if (proto_val_opt.has_value())
         {
-            auto proto_value = proto_it.value();
+            auto proto_value = proto_val_opt.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);
             }
         }
 
@@ -114,7 +128,7 @@ jspp::AnyValue jspp::JsArray::set_property(const std::string &key, const AnyValu
         auto it = props.find(key);
         if (it != props.end())
         {
-            return AnyValue::resolve_property_for_write(it->second, value);
+            return AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
         }
         else
         {
@@ -137,7 +151,8 @@ jspp::AnyValue jspp::JsArray::set_property(uint32_t idx, const AnyValue &value)
         {
             dense[idx] = AnyValue::make_undefined();
         }
-        return AnyValue::resolve_property_for_write(dense[idx].value(), value);
+        dense[idx] = value;
+        return value;
     }
     else if (idx <= dense.size() + DENSE_GROW_THRESHOLD)
     {
@@ -154,7 +169,8 @@ jspp::AnyValue jspp::JsArray::set_property(uint32_t idx, const AnyValue &value)
             {
                 it->second = AnyValue::make_undefined();
             }
-            return AnyValue::resolve_property_for_write(it->second.value(), value);
+            it->second = value;
+            return value;
         }
         else
         {

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

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

@@ -0,0 +1,107 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/iterator.hpp"
+#include "any_value.hpp"
+
+template <typename T>
+std::string jspp::JsIterator<T>::to_std_string() const
+{
+    return "[object Generator]";
+}
+
+template <typename T>
+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();
+
+    if (handle.promise().exception_)
+    {
+        std::rethrow_exception(handle.promise().exception_);
+    }
+
+    // If handle.done() is TRUE, we hit co_return (value: X, done: true)
+    // If handle.done() is FALSE, we hit co_yield (value: X, done: false)
+    bool is_done = handle.done();
+
+    return {handle.promise().current_value, is_done};
+}
+
+template <typename T>
+std::vector<std::optional<T>> jspp::JsIterator<T>::to_vector()
+{
+    std::vector<std::optional<AnyValue>> result;
+    while (true)
+    {
+        auto next = this->next();
+        if (next.done)
+        {
+            break;
+        }
+        result.push_back(next.value);
+    }
+    return result;
+}
+
+template <typename T>
+jspp::AnyValue jspp::JsIterator<T>::get_property(const std::string &key, const AnyValue &thisVal)
+{
+    auto it = props.find(key);
+    if (it == props.end())
+    {
+        // check prototype
+        if constexpr (std::is_same_v<T, AnyValue>)
+        {
+            auto proto_it = IteratorPrototypes::get(key, this);
+            if (proto_it.has_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, thisVal, key);
+}
+
+template <typename T>
+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>)
+    {
+        auto proto_it = IteratorPrototypes::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, thisVal, value, key);
+    }
+    else
+    {
+        props[key] = value;
+        return value;
+    }
+}

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

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/object.hpp"
+#include "any_value.hpp"
+
+std::string jspp::JsObject::to_std_string() const
+{
+    return "[Object Object]";
+}
+
+jspp::AnyValue jspp::JsObject::get_property(const std::string &key, const AnyValue &thisVal)
+{
+    auto it = props.find(key);
+    if (it == props.end())
+    {
+        // 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 AnyValue::resolve_property_for_read(it->second, thisVal, key);
+}
+
+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 AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
+    }
+    else
+    {
+        props[key] = 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](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

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/array.hpp"
+#include "values/string.hpp"
+#include "exception.hpp"
+#include "any_value.hpp"
+#include "values/prototypes/string.hpp"
+
+std::string jspp::JsString::to_std_string() const
+{
+    return value;
+}
+
+jspp::JsIterator<jspp::AnyValue> jspp::JsString::get_iterator()
+{
+    size_t strLength = value.length();
+    for (size_t idx = 0; idx < strLength; idx++)
+    {
+        co_yield AnyValue::make_string(std::string(1, value[idx]));
+    }
+    co_return AnyValue::make_undefined();
+}
+
+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();
+}
+
+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();
+}

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

@@ -0,0 +1,23 @@
+#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();
+}