@ugo-studio/jspp 0.3.0 → 0.3.2

package/src/prelude/values/iterator.hpp

@@ -3,16 +3,12 @@
 #include "types.hpp"
 #include <coroutine>
 #include <optional>
-#include <iostream>
-#include <utility>
-#include <exception>
+#include <vector>
 
 namespace jspp
 {
-    // Forward declaration of AnyValue
     class AnyValue;
 
-    // Special exception to signal a return from a generator
     struct GeneratorReturnException {};
 
     template <typename T>
@@ -36,91 +32,64 @@ namespace jspp
             std::exception_ptr pending_exception = nullptr;
             bool pending_return = false;
 
-            JsIterator get_return_object()
-            {
-                return JsIterator{
-                    std::coroutine_handle<promise_type>::from_promise(*this)};
-            }
+            JsIterator get_return_object();
+            std::suspend_always initial_suspend() noexcept;
+            std::suspend_always final_suspend() noexcept;
 
-            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 {}; }
+            struct Awaiter
+            {
+                promise_type &p;
+                bool await_ready() { return false; }
+                void await_suspend(std::coroutine_handle<promise_type>) {}
+                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;
+                }
+            };
 
-            // Handle co_yield
             template <typename From>
-            auto yield_value(From &&from)
-            {
+            Awaiter yield_value(From &&from) {
                 current_value = std::forward<From>(from);
-                struct Awaiter
-                {
-                    promise_type &p;
-                    bool await_ready() { return false; }
-                    void await_suspend(std::coroutine_handle<promise_type>) {}
-                    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};
             }
 
-            // 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)
-            {
+            void return_value(From &&from) {
                 current_value = std::forward<From>(from);
             }
 
-            void unhandled_exception()
-            {
-                try {
-                    throw;
-                } catch (const GeneratorReturnException&) {
-                    // Handled return
-                } catch (...) {
-                    exception_ = std::current_exception();
-                }
-            }
+            void unhandled_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)),
-              props(std::move(other.props)) {}
-
-        // Delete copy constructor/assignment to ensure unique ownership of the handle
+        explicit JsIterator(handle_type h);
+        JsIterator(JsIterator &&other) noexcept;
         JsIterator(const JsIterator &) = delete;
         JsIterator &operator=(const JsIterator &) = delete;
-
-        ~JsIterator()
-        {
-            if (handle)
-                handle.destroy();
-        }
+        ~JsIterator();
 
         std::unordered_map<std::string, AnyValue> props;
+        std::map<AnyValue, AnyValue> symbol_props;
 
         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();
+        bool has_symbol_property(const AnyValue &key) const;
         AnyValue get_property(const std::string &key, AnyValue thisVal);
+        AnyValue get_symbol_property(const AnyValue &key, AnyValue thisVal);
         AnyValue set_property(const std::string &key, AnyValue value, AnyValue thisVal);
+        AnyValue set_symbol_property(const AnyValue &key, AnyValue value, AnyValue thisVal);
     };
-}
+}

package/src/prelude/values/number.cpp

@@ -0,0 +1,221 @@
+#include "jspp.hpp"
+#include "values/prototypes/number.hpp"
+
+namespace jspp
+{
+
+    // --- JsNumber Implementation ---
+
+    namespace JsNumber
+    {
+        std::string to_std_string(double num)
+        {
+            if (std::isnan(num))
+                return "NaN";
+            if (std::abs(num) >= 1e21 || (std::abs(num) > 0 && std::abs(num) < 1e-6))
+            {
+                std::ostringstream oss;
+                oss << std::scientific << std::setprecision(4) << num;
+                return oss.str();
+            }
+            else
+            {
+                std::ostringstream oss;
+                oss << std::setprecision(6) << std::fixed << num;
+                std::string s = oss.str();
+                s.erase(s.find_last_not_of('0') + 1, std::string::npos);
+                if (!s.empty() && s.back() == '.')
+                    s.pop_back();
+                return s;
+            }
+        }
+
+        std::string to_std_string(const AnyValue &value)
+        {
+            return to_std_string(value.as_double());
+        }
+
+        std::string to_radix_string(double value, int radix)
+        {
+            if (std::isnan(value))
+                return "NaN";
+            if (!std::isfinite(value))
+                return value > 0 ? "Infinity" : "-Infinity";
+
+            long long intPart = static_cast<long long>(value);
+
+            if (radix == 10)
+            {
+                return AnyValue::make_number(value).to_std_string();
+            }
+
+            bool negative = intPart < 0;
+            if (negative)
+                intPart = -intPart;
+
+            std::string chars = "0123456789abcdefghijklmnopqrstuvwxyz";
+            std::string res = "";
+
+            if (intPart == 0)
+                res = "0";
+            else
+            {
+                while (intPart > 0)
+                {
+                    res += chars[intPart % radix];
+                    intPart /= radix;
+                }
+            }
+            if (negative)
+                res += "-";
+            std::reverse(res.begin(), res.end());
+            return res;
+        }
+
+    }
+
+    // --- NumberPrototypes Implementation ---
+
+    namespace NumberPrototypes
+    {
+
+        AnyValue &get_toExponential_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
+                                                     double self = thisVal.as_double();
+                                                     int digits = -1;
+                                                     if (!args.empty() && !args[0].is_undefined())
+                                                     {
+                                                         digits = Operators_Private::ToInt32(args[0]);
+                                                         if (digits < 0 || digits > 100)
+                                                         {
+                                                             throw Exception::make_exception("toExponential() digits argument must be between 0 and 100", "RangeError");
+                                                         }
+                                                     }
+
+                                                     std::ostringstream ss;
+                                                     if (digits >= 0)
+                                                     {
+                                                         ss << std::scientific << std::setprecision(digits) << self;
+                                                     }
+                                                     else
+                                                     {
+                                                         ss << std::scientific << self;
+                                                     }
+
+                                                     std::string res = ss.str();
+                                                     return AnyValue::make_string(res); },
+                                                         "toExponential");
+            return fn;
+        }
+
+        AnyValue &get_toFixed_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
+                                                     double self = thisVal.as_double();
+                                                     int digits = 0;
+                                                     if (!args.empty() && !args[0].is_undefined())
+                                                     {
+                                                         digits = Operators_Private::ToInt32(args[0]);
+                                                     }
+                                                     if (digits < 0 || digits > 100)
+                                                     {
+                                                         throw Exception::make_exception("toFixed() digits argument must be between 0 and 100", "RangeError");
+                                                     }
+
+                                                     std::ostringstream ss;
+                                                     ss << std::fixed << std::setprecision(digits) << self;
+                                                     return AnyValue::make_string(ss.str()); },
+                                                         "toFixed");
+            return fn;
+        }
+
+        AnyValue &get_toPrecision_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
+                                                     double self = thisVal.as_double();
+                                                     if (args.empty() || args[0].is_undefined())
+                                                     {
+                                                         return AnyValue::make_number(self).get_own_property("toString").call(AnyValue::make_number(self), {}, "toString");
+                                                     }
+                                                     int precision = Operators_Private::ToInt32(args[0]);
+                                                     if (precision < 1 || precision > 100)
+                                                     {
+                                                         throw Exception::make_exception("toPrecision() precision argument must be between 1 and 100", "RangeError");
+                                                     }
+
+                                                     std::ostringstream ss;
+                                                     ss << std::setprecision(precision) << self;
+                                                     return AnyValue::make_string(ss.str()); },
+                                                         "toPrecision");
+            return fn;
+        }
+
+        AnyValue &get_toString_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
+                                                     double self = thisVal.as_double();
+                                                     int radix = 10;
+                                                     if (!args.empty() && !args[0].is_undefined())
+                                                     {
+                                                         radix = Operators_Private::ToInt32(args[0]);
+                                                     }
+                                                     if (radix < 2 || radix > 36)
+                                                     {
+                                                         throw Exception::make_exception("toString() radix argument must be between 2 and 36", "RangeError");
+                                                     }
+
+                                                     return AnyValue::make_string(JsNumber::to_radix_string(self, radix)); },
+                                                         "toString");
+            return fn;
+        }
+
+        AnyValue &get_valueOf_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                         { return AnyValue::make_number(thisVal.as_double()); },
+                                                         "valueOf");
+            return fn;
+        }
+
+        AnyValue &get_toLocaleString_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                         { return AnyValue::make_string(AnyValue::make_number(thisVal.as_double()).to_std_string()); },
+                                                         "toLocaleString");
+            return fn;
+        }
+
+        std::optional<AnyValue> get(const std::string &key)
+        {
+            if (key == "toExponential")
+                return get_toExponential_fn();
+            if (key == "toFixed")
+                return get_toFixed_fn();
+            if (key == "toPrecision")
+                return get_toPrecision_fn();
+            if (key == "toString")
+                return get_toString_fn();
+            if (key == "valueOf")
+                return get_valueOf_fn();
+            if (key == "toLocaleString")
+                return get_toLocaleString_fn();
+            return std::nullopt;
+        }
+
+        std::optional<AnyValue> get(const AnyValue &key)
+        {
+            if (key == "toString" || key == AnyValue::from_symbol(WellKnownSymbols::toStringTag))
+                return get_toString_fn();
+            if (key == "valueOf")
+                return get_valueOf_fn();
+            return std::nullopt;
+        }
+
+    } // namespace NumberPrototypes
+
+} // namespace jspp

package/src/prelude/values/object.cpp

@@ -0,0 +1,200 @@
+#include "jspp.hpp"
+#include "values/object.hpp"
+#include "values/prototypes/object.hpp"
+
+namespace jspp
+{
+
+    // --- JsObject Implementation ---
+
+    JsObject::JsObject() : shape(Shape::empty_shape()), proto(Constants::Null) {}
+
+    JsObject::JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, 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, 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 JsObject::to_std_string() const
+    {
+        return "[Object Object]";
+    }
+
+    bool 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.is_null() && !proto.is_undefined())
+        {
+            if (proto.has_property(key))
+                return true;
+        }
+        if (ObjectPrototypes::get(key).has_value())
+            return true;
+        return false;
+    }
+
+    bool JsObject::has_symbol_property(const AnyValue &key) const
+    {
+        if (symbol_props.count(key))
+            return true;
+        if (!proto.is_null() && !proto.is_undefined())
+        {
+            if (proto.has_property(key))
+                return true;
+        }
+        if (ObjectPrototypes::get(key).has_value())
+            return true;
+        return false;
+    }
+
+    AnyValue JsObject::get_property(const std::string &key, const AnyValue &thisVal)
+    {
+        if (deleted_keys.count(key))
+            return Constants::UNDEFINED;
+
+        auto offset = shape->get_offset(key);
+        if (!offset.has_value())
+        {
+            if (!proto.is_null() && !proto.is_undefined())
+            {
+                if (proto.has_property(key))
+                {
+                    return proto.get_property_with_receiver(key, thisVal);
+                }
+            }
+
+            auto proto_it = ObjectPrototypes::get(key);
+            if (proto_it.has_value())
+            {
+                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+            }
+            return Constants::UNDEFINED;
+        }
+        return AnyValue::resolve_property_for_read(storage[offset.value()], thisVal, key);
+    }
+
+    AnyValue JsObject::get_symbol_property(const AnyValue &key, const AnyValue &thisVal)
+    {
+        auto it = symbol_props.find(key);
+        if (it == symbol_props.end())
+        {
+            if (!proto.is_null() && !proto.is_undefined())
+            {
+                auto res = proto.get_symbol_property_with_receiver(key, thisVal);
+                if (!res.is_undefined())
+                    return res;
+            }
+
+            auto proto_it = ObjectPrototypes::get(key);
+            if (proto_it.has_value())
+            {
+                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key.to_std_string());
+            }
+            return Constants::UNDEFINED;
+        }
+        return AnyValue::resolve_property_for_read(it->second, thisVal, key.to_std_string());
+    }
+
+    AnyValue JsObject::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+    {
+        auto proto_it = ObjectPrototypes::get(key);
+        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);
+            }
+        }
+
+        if (deleted_keys.count(key))
+            deleted_keys.erase(key);
+
+        auto offset = shape->get_offset(key);
+        if (offset.has_value())
+        {
+            return AnyValue::resolve_property_for_write(storage[offset.value()], thisVal, value, key);
+        }
+        else
+        {
+            shape = shape->transition(key);
+            storage.push_back(value);
+            return value;
+        }
+    }
+
+    AnyValue JsObject::set_symbol_property(const AnyValue &key, const AnyValue &value, const AnyValue &thisVal)
+    {
+        auto it = symbol_props.find(key);
+        if (it != symbol_props.end())
+        {
+            return AnyValue::resolve_property_for_write(it->second, thisVal, value, key.to_std_string());
+        }
+        else
+        {
+            symbol_props[key] = value;
+            return value;
+        }
+    }
+
+    // --- ObjectPrototypes Implementation ---
+
+    namespace ObjectPrototypes
+    {
+
+        AnyValue &get_toString_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
+                                                         { return AnyValue::make_string(thisVal.to_std_string()); },
+                                                         "toString");
+            return fn;
+        }
+
+        std::optional<AnyValue> get(const std::string &key)
+        {
+            if (key == "toString")
+            {
+                return get_toString_fn();
+            }
+            return std::nullopt;
+        }
+
+        std::optional<AnyValue> get(const AnyValue &key)
+        {
+            if (key.is_string())
+                return get(key.as_string()->value);
+
+            if (key == AnyValue::from_symbol(WellKnownSymbols::toStringTag))
+            {
+                return get_toString_fn();
+            }
+            return std::nullopt;
+        }
+
+    } // namespace ObjectPrototypes
+
+} // namespace jspp

package/src/prelude/values/object.hpp

@@ -16,6 +16,7 @@ namespace jspp
         std::vector<AnyValue> storage;
         AnyValue proto;
         std::unordered_set<std::string> deleted_keys;
+        std::map<AnyValue, AnyValue> symbol_props;
 
         JsObject();
         JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, AnyValue pr);
@@ -25,7 +26,10 @@ namespace jspp
 
         std::string to_std_string() const;
         bool has_property(const std::string &key) const;
+        bool has_symbol_property(const AnyValue &key) const;
         AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+        AnyValue get_symbol_property(const AnyValue &key, const AnyValue &thisVal);
         AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
+        AnyValue set_symbol_property(const AnyValue &key, const AnyValue &value, const AnyValue &thisVal);
     };
 }