@ugo-studio/jspp 0.1.2 → 0.1.3

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

@@ -47,6 +47,16 @@ std::string jspp::JsArray::to_std_string() const
     return result;
 }
 
+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)
 {
     if (
@@ -100,14 +110,11 @@ 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();
-            if (proto_value.is_accessor_descriptor())
-            {
-                return AnyValue::resolve_property_for_write(proto_it.value(), value);
-            }
+            auto proto_value = proto_val_opt.value();
+            return AnyValue::resolve_property_for_write(proto_value, value);
         }
 
         // set own property

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

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

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

@@ -0,0 +1,101 @@
+#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()
+{
+    // If the generator is already finished or invalid, return {undefined, true}
+    if (!handle || handle.done())
+        return {std::nullopt, true};
+
+    // 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)
+{
+    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());
+            }
+        }
+        // prototype not found
+        return jspp::AnyValue::make_undefined();
+    }
+
+    return jspp::AnyValue::resolve_property_for_read(it->second);
+}
+
+template <typename T>
+jspp::AnyValue jspp::JsIterator<T>::set_property(const std::string &key, const AnyValue &value)
+{
+    // 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_it.value(), value);
+            }
+        }
+    }
+
+    // set own property
+    auto it = props.find(key);
+    if (it != props.end())
+    {
+        return jspp::AnyValue::resolve_property_for_write(it->second, value);
+    }
+    else
+    {
+        props[key] = value;
+        return value;
+    }
+}

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 "error.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)
+{
+    // 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());
+    }
+    // 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)
+{
+    // check prototype
+    auto proto_it = SymbolPrototypes::get(key, this);
+    if (proto_it.has_value())
+    {
+        return AnyValue::resolve_property_for_read(proto_it.value());
+    }
+    // not found
+    return AnyValue::make_undefined();
+}

package/src/prelude/values/iterator.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "types.hpp"
+#include <coroutine>
+#include <optional>
+#include <iostream>
+#include <utility>
+#include <exception>
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    template <typename T>
+    class JsIterator
+    {
+    public:
+        struct NextResult
+        {
+            std::optional<T> value;
+            bool done;
+        };
+        struct promise_type
+        {
+            std::optional<T> current_value;
+            std::exception_ptr exception_;
+
+            JsIterator get_return_object()
+            {
+                return JsIterator{
+                    std::coroutine_handle<promise_type>::from_promise(*this)};
+            }
+
+            std::suspend_always initial_suspend() noexcept { return {}; }
+
+            // valid js generators allow access to the return value after completion,
+            // so we must suspend at the end to keep the promise (and value) alive.
+            std::suspend_always final_suspend() noexcept { return {}; }
+
+            // Handle co_yield
+            template <typename From>
+            std::suspend_always yield_value(From &&from)
+            {
+                current_value = std::forward<From>(from);
+                return {};
+            }
+
+            // Handle co_return
+            // This replaces return_void.
+            // It captures the final value and moves to final_suspend (implicit).
+            template <typename From>
+            void return_value(From &&from)
+            {
+                current_value = std::forward<From>(from);
+            }
+
+            void unhandled_exception()
+            {
+                exception_ = std::current_exception();
+            }
+        };
+
+        using handle_type = std::coroutine_handle<promise_type>;
+        handle_type handle;
+
+        explicit JsIterator(handle_type h) : handle(h) {}
+        JsIterator(JsIterator &&other) noexcept : handle(std::exchange(other.handle, nullptr)) {}
+
+        // Delete copy constructor/assignment to ensure unique ownership of the handle
+        JsIterator(const JsIterator &) = delete;
+        JsIterator &operator=(const JsIterator &) = delete;
+
+        ~JsIterator()
+        {
+            if (handle)
+                handle.destroy();
+        }
+
+        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);
+    };
+}

package/src/prelude/values/object.hpp

@@ -4,11 +4,12 @@
 
 namespace jspp
 {
+    // Forward declaration of AnyValue
     class AnyValue;
 
     struct JsObject
     {
-        std::unordered_map<std::string, AnyValue> props;
+        std::map<std::string, AnyValue> props;
 
         std::string to_std_string() const;
         AnyValue get_property(const std::string &key);

package/src/prelude/values/prototypes/array.hpp

@@ -14,24 +14,31 @@ namespace jspp
     {
         inline std::optional<AnyValue> get(const std::string &key, JsArray *self)
         {
-
             // --- toString() method ---
-            if (key == "toString")
+            if (key == "toString" || key == WellKnownSymbols::toString->key)
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const std::vector<AnyValue> &_) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }
 
+            // --- [Symbol.iterator]() method ---
+            if (key == WellKnownSymbols::iterator->key)
+            {
+                return AnyValue::make_generator([self](const std::vector<AnyValue> &_) -> AnyValue
+                                                { return AnyValue::from_iterator(self->get_iterator()); },
+                                                key);
+            }
+
             // --- length property ---
             if (key == "length")
             {
-                auto getter = [&self](const std::vector<AnyValue> &args) -> AnyValue
+                auto getter = [self](const std::vector<AnyValue> &args) -> AnyValue
                 {
                     return AnyValue::make_number(self->length);
                 };
 
-                auto setter = [&self](const std::vector<AnyValue> &args) -> AnyValue
+                auto setter = [self](const std::vector<AnyValue> &args) -> AnyValue
                 {
                     if (args.empty())
                     {
@@ -79,7 +86,7 @@ namespace jspp
             // --- push() method ---
             if (key == "push")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            for (const auto &arg : args)
                                                                                            {
@@ -92,7 +99,7 @@ namespace jspp
             // --- pop() method ---
             if (key == "pop")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            if (self->length == 0)
                                                                                            {
@@ -117,7 +124,7 @@ namespace jspp
             // --- shift() method ---
             if (key == "shift")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            if (self->length == 0)
                                                                                            {
@@ -148,7 +155,7 @@ namespace jspp
             // --- unshift() method ---
             if (key == "unshift")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                              size_t args_count = args.size();
                                                                                              if (args_count == 0)
@@ -175,7 +182,7 @@ namespace jspp
             // --- join() method ---
             if (key == "join")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            std::string sep = ",";
                                                                                            if (!args.empty() && !args[0].is_undefined())
@@ -203,7 +210,7 @@ namespace jspp
             // --- forEach() method ---
             if (key == "forEach")
             {
-                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            if (args.empty() || !args[0].is_function())
                                                                                            {

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/function.hpp"
+#include "any_value.hpp"
+#include "error.hpp"
+#include "operators.hpp"
+
+namespace jspp
+{
+    namespace FunctionPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsFunction *self)
+        {
+            // --- toString() method ---
+            if (key == "toString" || key == WellKnownSymbols::toString->key)
+            {
+                return AnyValue::make_function([self](const std::vector<AnyValue> &_) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/iterator.hpp"
+#include "any_value.hpp"
+#include "error.hpp"
+#include "operators.hpp"
+
+namespace jspp
+{
+    namespace IteratorPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsIterator<AnyValue> *self)
+        {
+            // --- toString() method ---
+            if (key == "toString" || key == WellKnownSymbols::toString->key)
+            {
+                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+            // --- [Symbol.iterator]() method ---
+            if (key == WellKnownSymbols::iterator->key)
+            {
+                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
+                                               {
+                                                   // An iterator's iterator is itself.
+                                                   // We need to return an AnyValue that holds a shared_ptr to this JsIterator.
+                                                   // Since we only have a raw pointer `self`, we can't directly make a new shared_ptr.
+                                                   // We'll return an AnyValue wrapping the raw pointer for now.
+                                                   // This relies on the calling context to manage lifetime, which is true for `for-of`.
+                                                   // A better solution might involve passing a shared_ptr to `self` into the prototype getters.
+                                                   // For now, let's assume the object containing the iterator is alive.
+                                                   return AnyValue::from_iterator_ref(self); },
+                                               key);
+            }
+            // --- next() method ---
+            if (key == "next")
+            {
+                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
+                                               {
+                                                auto res = self->next();
+                                                return AnyValue::make_object({{"value",res.value.value_or(AnyValue::make_undefined())},{"done",AnyValue::make_boolean(res.done)},}); },
+                                               key);
+            }
+            // --- toArray() method ---
+            if (key == "toArray")
+            {
+                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
+                                               { return AnyValue::make_array(self->to_vector()); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}