@ugo-studio/jspp 0.2.8 → 0.2.9

package/src/prelude/utils/operators.hpp

@@ -327,4 +327,11 @@ namespace jspp
             lhs = rhs;
         return lhs;
     }
+
+    inline AnyValue undefined_coalesce(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        if (!lhs.is_undefined())
+            return lhs;
+        return rhs;
+    }
 }

package/src/prelude/values/async_iterator.hpp

@@ -56,7 +56,9 @@ namespace jspp
         handle_type handle;
 
         explicit JsAsyncIterator(handle_type h) : handle(h) {}
-        JsAsyncIterator(JsAsyncIterator &&other) noexcept : handle(std::exchange(other.handle, nullptr)) {}
+        JsAsyncIterator(JsAsyncIterator &&other) noexcept 
+            : handle(std::exchange(other.handle, nullptr)),
+              props(std::move(other.props)) {}
 
         JsAsyncIterator(const JsAsyncIterator &) = delete;
         JsAsyncIterator &operator=(const JsAsyncIterator &) = delete;
@@ -73,8 +75,8 @@ namespace jspp
 
         JsPromise next(const T &val = T());
 
-        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
-        AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
+        AnyValue get_property(const std::string &key, AnyValue thisVal);
+        AnyValue set_property(const std::string &key, AnyValue value, AnyValue thisVal);
 
         void resume_next();
     };

package/src/prelude/values/function.hpp

@@ -73,10 +73,10 @@ namespace jspp
     JsType get_heap_type() const override { return JsType::Function; }
 
     std::string to_std_string() const;
-    AnyValue call(const AnyValue &thisVal, std::span<const AnyValue> args);
+    AnyValue call(AnyValue thisVal, std::span<const AnyValue> args);
 
     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);
+    AnyValue get_property(const std::string &key, AnyValue thisVal);
+    AnyValue set_property(const std::string &key, AnyValue value, AnyValue thisVal);
   };
 }

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

@@ -14,7 +14,7 @@ std::string jspp::JsAsyncIterator<T>::to_std_string() const
 }
 
 template <typename T>
-jspp::AnyValue jspp::JsAsyncIterator<T>::get_property(const std::string &key, const AnyValue &thisVal)
+jspp::AnyValue jspp::JsAsyncIterator<T>::get_property(const std::string &key, AnyValue thisVal)
 {
     auto it = props.find(key);
     if (it == props.end())
@@ -33,7 +33,7 @@ jspp::AnyValue jspp::JsAsyncIterator<T>::get_property(const std::string &key, co
 }
 
 template <typename T>
-jspp::AnyValue jspp::JsAsyncIterator<T>::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+jspp::AnyValue jspp::JsAsyncIterator<T>::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
 {
     if constexpr (std::is_same_v<T, AnyValue>)
     {
@@ -87,8 +87,12 @@ void jspp::JsAsyncIterator<T>::resume_next()
     // After yield/return, if more calls are pending, handle them.
     if (!p.pending_calls.empty() && !p.is_awaiting && !handle.done())
     {
+        this->ref();
         Scheduler::instance().enqueue([this]()
-                                      { this->resume_next(); });
+                                      { 
+                                          this->resume_next(); 
+                                          this->deref();
+                                      });
     }
 }
 

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

@@ -18,23 +18,23 @@ namespace jspp
         return type_part + " " + name_part + "() { [native code] }";
     }
 
-    inline AnyValue JsFunction::call(const AnyValue &thisVal, std::span<const AnyValue> args)
+    inline AnyValue JsFunction::call(AnyValue thisVal, std::span<const AnyValue> args)
     {
-        if (std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<0>(&callable))
+        if (std::function<AnyValue(AnyValue, std::span<const AnyValue>)> *func = std::get_if<0>(&callable))
         {
             return (*func)(thisVal, args);
         }
-        else if (std::function<jspp::JsIterator<jspp::AnyValue>(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<1>(&callable))
+        else if (std::function<jspp::JsIterator<jspp::AnyValue>(AnyValue, std::vector<AnyValue>)> *func = std::get_if<1>(&callable))
         {
-            return AnyValue::from_iterator((*func)(thisVal, args));
+            return AnyValue::from_iterator((*func)(thisVal, std::vector<AnyValue>(args.begin(), args.end())));
         }
-        else if (std::function<jspp::JsPromise(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<2>(&callable))
+        else if (std::function<jspp::JsPromise(AnyValue, std::vector<AnyValue>)> *func = std::get_if<2>(&callable))
         {
-            return AnyValue::make_promise((*func)(thisVal, args));
+            return AnyValue::make_promise((*func)(thisVal, std::vector<AnyValue>(args.begin(), args.end())));
         }
-        else if (std::function<jspp::JsAsyncIterator<jspp::AnyValue>(const AnyValue &, std::span<const AnyValue>)> *func = std::get_if<3>(&callable))
+        else if (std::function<jspp::JsAsyncIterator<jspp::AnyValue>(AnyValue, std::vector<AnyValue>)> *func = std::get_if<3>(&callable))
         {
-            return AnyValue::from_async_iterator((*func)(thisVal, args));
+            return AnyValue::from_async_iterator((*func)(thisVal, std::vector<AnyValue>(args.begin(), args.end())));
         }
         else
         {
@@ -56,7 +56,7 @@ namespace jspp
         return false;
     }
 
-    inline AnyValue JsFunction::get_property(const std::string &key, const AnyValue &thisVal)
+    inline AnyValue JsFunction::get_property(const std::string &key, AnyValue thisVal)
     {
         auto it = props.find(key);
         if (it == props.end())
@@ -79,7 +79,7 @@ namespace jspp
         return AnyValue::resolve_property_for_read(it->second, thisVal, key);
     }
 
-    inline AnyValue JsFunction::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+    inline AnyValue JsFunction::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
     {
         auto proto_it = FunctionPrototypes::get(key);
         if (proto_it.has_value())

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

@@ -35,6 +35,43 @@ typename jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::next(const T &val)
     return {handle.promise().current_value, is_done};
 }
 
+template <typename T>
+typename jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::return_(const T &val)
+{
+    if (!handle || handle.done())
+        return {val, true};
+
+    handle.promise().pending_return = true;
+    handle.promise().current_value = val;
+    handle.resume();
+
+    if (handle.promise().exception_)
+    {
+        std::rethrow_exception(handle.promise().exception_);
+    }
+
+    return {handle.promise().current_value, true};
+}
+
+template <typename T>
+typename jspp::JsIterator<T>::NextResult jspp::JsIterator<T>::throw_(const AnyValue &err)
+{
+    if (!handle || handle.done()) {
+        throw Exception(err);
+    }
+
+    handle.promise().pending_exception = std::make_exception_ptr(Exception(err));
+    handle.resume();
+
+    if (handle.promise().exception_)
+    {
+        std::rethrow_exception(handle.promise().exception_);
+    }
+
+    bool is_done = handle.done();
+    return {handle.promise().current_value, is_done};
+}
+
 template <typename T>
 std::vector<T> jspp::JsIterator<T>::to_vector()
 {
@@ -52,7 +89,7 @@ std::vector<T> jspp::JsIterator<T>::to_vector()
 }
 
 template <typename T>
-jspp::AnyValue jspp::JsIterator<T>::get_property(const std::string &key, const AnyValue &thisVal)
+jspp::AnyValue jspp::JsIterator<T>::get_property(const std::string &key, AnyValue thisVal)
 {
     auto it = props.find(key);
     if (it == props.end())
@@ -74,7 +111,7 @@ jspp::AnyValue jspp::JsIterator<T>::get_property(const std::string &key, const A
 }
 
 template <typename T>
-jspp::AnyValue jspp::JsIterator<T>::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+jspp::AnyValue jspp::JsIterator<T>::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
 {
     // set prototype property if accessor descriptor
     if constexpr (std::is_same_v<T, AnyValue>)

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

@@ -12,7 +12,7 @@ namespace jspp
 
     inline JsPromise::JsPromise() : state(std::make_shared<PromiseState>()) {}
 
-    inline void JsPromise::resolve(const AnyValue &value)
+    inline void JsPromise::resolve(AnyValue value)
     {
         if (state->status != PromiseStatus::Pending)
             return;
@@ -29,7 +29,7 @@ namespace jspp
             auto weak_state = std::weak_ptr<PromiseState>(state);
 
             p->then(
-                [weak_state](const AnyValue &v)
+                [weak_state](AnyValue v)
                 {
                     if (auto s = weak_state.lock())
                     {
@@ -49,7 +49,7 @@ namespace jspp
                                                                 { cb(v); });
                     }
                 },
-                [weak_state](const AnyValue &r)
+                [weak_state](AnyValue r)
                 {
                     if (auto s = weak_state.lock())
                     {
@@ -81,7 +81,7 @@ namespace jspp
         }
     }
 
-    inline void JsPromise::reject(const AnyValue &reason)
+    inline void JsPromise::reject(AnyValue reason)
     {
         if (state->status != PromiseStatus::Pending)
             return;
@@ -99,7 +99,7 @@ namespace jspp
         }
     }
 
-    inline void JsPromise::then(std::function<void(const AnyValue &)> onFulfilled, std::function<void(const AnyValue &)> onRejected)
+    inline void JsPromise::then(std::function<void(AnyValue)> onFulfilled, std::function<void(AnyValue)> onRejected)
     {
         if (state->status == PromiseStatus::Fulfilled)
         {
@@ -140,7 +140,7 @@ namespace jspp
         return "[object Promise]";
     }
 
-    inline AnyValue JsPromise::get_property(const std::string &key, const AnyValue &thisVal)
+    inline AnyValue JsPromise::get_property(const std::string &key, AnyValue thisVal)
     {
         // Prototype lookup
         auto proto_it = PromisePrototypes::get(key);
@@ -157,7 +157,7 @@ namespace jspp
         return Constants::UNDEFINED;
     }
 
-    inline AnyValue JsPromise::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+    inline AnyValue JsPromise::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
     {
         auto it = props.find(key);
         if (it != props.end())
@@ -173,7 +173,7 @@ namespace jspp
 
     // --- Coroutine Methods ---
 
-    inline void JsPromisePromiseType::return_value(const AnyValue &val)
+    inline void JsPromisePromiseType::return_value(AnyValue val)
     {
         promise.resolve(val);
     }
@@ -198,7 +198,7 @@ namespace jspp
         }
     }
 
-    inline auto JsPromisePromiseType::await_transform(const AnyValue &value)
+    inline auto JsPromisePromiseType::await_transform(AnyValue value)
     {
         return AnyValueAwaiter{value};
     }

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

@@ -14,10 +14,24 @@ inline std::string jspp::JsString::to_std_string() const
 
 inline jspp::JsIterator<jspp::AnyValue> jspp::JsString::get_iterator()
 {
-    size_t strLength = value.length();
-    for (size_t idx = 0; idx < strLength; idx++)
+    for (size_t i = 0; i < value.length();)
     {
-        co_yield AnyValue::make_string(std::string(1, value[idx]));
+        unsigned char c = static_cast<unsigned char>(value[i]);
+        size_t len = 1;
+        if ((c & 0x80) == 0)
+            len = 1;
+        else if ((c & 0xE0) == 0xC0)
+            len = 2;
+        else if ((c & 0xF0) == 0xE0)
+            len = 3;
+        else if ((c & 0xF8) == 0xF0)
+            len = 4;
+
+        if (i + len > value.length())
+            len = value.length() - i;
+
+        co_yield AnyValue::make_string(value.substr(i, len));
+        i += len;
     }
     co_return AnyValue::make_undefined();
 }

package/src/prelude/values/iterator.hpp

@@ -12,6 +12,9 @@ namespace jspp
     // Forward declaration of AnyValue
     class AnyValue;
 
+    // Special exception to signal a return from a generator
+    struct GeneratorReturnException {};
+
     template <typename T>
     class JsIterator : public HeapObject
     {
@@ -30,6 +33,9 @@ namespace jspp
             std::exception_ptr exception_;
             T input_value;
 
+            std::exception_ptr pending_exception = nullptr;
+            bool pending_return = false;
+
             JsIterator get_return_object()
             {
                 return JsIterator{
@@ -52,7 +58,18 @@ namespace jspp
                     promise_type &p;
                     bool await_ready() { return false; }
                     void await_suspend(std::coroutine_handle<promise_type>) {}
-                    T await_resume() { return p.input_value; }
+                    T await_resume() {
+                        if (p.pending_exception) {
+                            auto ex = p.pending_exception;
+                            p.pending_exception = nullptr;
+                            std::rethrow_exception(ex);
+                        }
+                        if (p.pending_return) {
+                            p.pending_return = false;
+                            throw GeneratorReturnException{};
+                        }
+                        return p.input_value;
+                    }
                 };
                 return Awaiter{*this};
             }
@@ -68,7 +85,13 @@ namespace jspp
 
             void unhandled_exception()
             {
-                exception_ = std::current_exception();
+                try {
+                    throw;
+                } catch (const GeneratorReturnException&) {
+                    // Handled return
+                } catch (...) {
+                    exception_ = std::current_exception();
+                }
             }
         };
 
@@ -76,7 +99,9 @@ namespace jspp
         handle_type handle;
 
         explicit JsIterator(handle_type h) : handle(h) {}
-        JsIterator(JsIterator &&other) noexcept : handle(std::exchange(other.handle, nullptr)) {}
+        JsIterator(JsIterator &&other) noexcept 
+            : handle(std::exchange(other.handle, nullptr)),
+              props(std::move(other.props)) {}
 
         // Delete copy constructor/assignment to ensure unique ownership of the handle
         JsIterator(const JsIterator &) = delete;
@@ -92,8 +117,10 @@ namespace jspp
 
         std::string to_std_string() const;
         NextResult next(const T &val = T());
+        NextResult return_(const T &val = T());
+        NextResult throw_(const AnyValue &err);
         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);
+        AnyValue get_property(const std::string &key, AnyValue thisVal);
+        AnyValue set_property(const std::string &key, AnyValue value, AnyValue thisVal);
     };
 }

package/src/prelude/values/promise.hpp

@@ -41,14 +41,14 @@ namespace jspp
         JsType get_heap_type() const override { return JsType::Promise; }
 
         // --- 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);
+        void resolve(AnyValue value);
+        void reject(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);
+        AnyValue get_property(const std::string& key, AnyValue thisVal);
+        AnyValue set_property(const std::string& key, AnyValue value, AnyValue thisVal);
 
         auto operator co_await() const;
     };
@@ -60,12 +60,12 @@ namespace jspp
         std::suspend_never initial_suspend() { return {}; }
         std::suspend_never final_suspend() noexcept { return {}; }
         
-        void return_value(const AnyValue& val);
+        void return_value(AnyValue val);
         
         void unhandled_exception();
         
         // await_transform for AnyValue
-        auto await_transform(const AnyValue& value);
+        auto await_transform(AnyValue value);
         // await_transform for JsPromise
         auto await_transform(const JsPromise& value);
     };