@ugo-studio/jspp 0.3.0 → 0.3.2

package/src/prelude/values/function.cpp

@@ -0,0 +1,262 @@
+#include "jspp.hpp"
+#include "values/function.hpp"
+#include "values/prototypes/function.hpp"
+
+namespace jspp {
+
+// --- JsFunction Implementation ---
+
+JsFunction::JsFunction(const JsFunctionCallable &c,
+                        std::optional<std::string> n,
+                        std::unordered_map<std::string, AnyValue> p,
+                        std::map<AnyValue, AnyValue> sp,
+                        bool is_cls,
+                        bool is_ctor)
+    : callable(c),
+        name(std::move(n)),
+        props(std::move(p)),
+        symbol_props(std::move(sp)),
+        proto(Constants::Null),
+        is_generator(callable.index() == 1),
+        is_async(callable.index() == 2),
+        is_class(is_cls),
+        is_constructor(is_ctor && !is_generator && !is_async)
+{
+}
+
+JsFunction::JsFunction(const JsFunctionCallable &c,
+                        bool is_gen,
+                        std::optional<std::string> n,
+                        std::unordered_map<std::string, AnyValue> p,
+                        std::map<AnyValue, AnyValue> sp,
+                        bool is_cls,
+                        bool is_ctor)
+    : callable(c),
+        name(std::move(n)),
+        props(std::move(p)),
+        symbol_props(std::move(sp)),
+        proto(Constants::Null),
+        is_generator(is_gen),
+        is_async(callable.index() == 2),
+        is_class(is_cls),
+        is_constructor(is_ctor && !is_gen && !is_async)
+{
+}
+
+JsFunction::JsFunction(const JsFunctionCallable &c,
+                        bool is_gen,
+                        bool is_async_func,
+                        std::optional<std::string> n,
+                        std::unordered_map<std::string, AnyValue> p,
+                        std::map<AnyValue, AnyValue> sp,
+                        bool is_cls,
+                        bool is_ctor)
+    : callable(c),
+        name(std::move(n)),
+        props(std::move(p)),
+        symbol_props(std::move(sp)),
+        proto(Constants::Null),
+        is_generator(is_gen),
+        is_async(is_async_func),
+        is_class(is_cls),
+        is_constructor(is_ctor && !is_gen && !is_async_func)
+{
+}
+
+std::string JsFunction::to_std_string() const
+{
+    std::string type_part = this->is_async ? "async function" : this->is_generator ? "function*"
+                                                                                    : "function";
+    std::string name_part = this->name.value_or("");
+    return type_part + " " + name_part + "() { [native code] }";
+}
+
+AnyValue JsFunction::call(AnyValue thisVal, std::span<const AnyValue> args)
+{
+    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>(AnyValue, std::vector<AnyValue>)> *func = std::get_if<1>(&callable))
+    {
+        return AnyValue::from_iterator((*func)(thisVal, std::vector<AnyValue>(args.begin(), args.end())));
+    }
+    else if (std::function<jspp::JsPromise(AnyValue, std::vector<AnyValue>)> *func = std::get_if<2>(&callable))
+    {
+        return AnyValue::from_promise((*func)(thisVal, std::vector<AnyValue>(args.begin(), args.end())));
+    }
+    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, std::vector<AnyValue>(args.begin(), args.end())));
+    }
+    else
+    {
+        return Constants::UNDEFINED;
+    }
+}
+
+bool JsFunction::has_property(const std::string &key) const
+{
+    if (props.find(key) != props.end())
+        return true;
+    if (!proto.is_null() && !proto.is_undefined())
+    {
+        if (proto.has_property(key))
+            return true;
+    }
+    if (FunctionPrototypes::get(key).has_value())
+        return true;
+    return false;
+}
+
+bool JsFunction::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 (FunctionPrototypes::get(key).has_value())
+        return true;
+    return false;
+}
+
+AnyValue JsFunction::get_property(const std::string &key, AnyValue thisVal)
+{
+    auto it = props.find(key);
+    if (it == props.end())
+    {
+        if (!proto.is_null() && !proto.is_undefined())
+        {
+            if (proto.has_property(key))
+            {
+                return proto.get_property_with_receiver(key, thisVal);
+            }
+        }
+
+        auto proto_it = FunctionPrototypes::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(it->second, thisVal, key);
+}
+
+AnyValue JsFunction::get_symbol_property(const AnyValue &key, 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 = FunctionPrototypes::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 JsFunction::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
+{
+    auto proto_it = FunctionPrototypes::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);
+        }
+    }
+
+    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 JsFunction::set_symbol_property(const AnyValue &key, AnyValue value, 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;
+    }
+}
+
+// --- FunctionPrototypes Implementation ---
+
+namespace FunctionPrototypes {
+
+AnyValue &get_toString_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
+                                                 { return AnyValue::make_string(thisVal.as_function()->to_std_string()); },
+                                                 "toString");
+    return fn;
+}
+
+AnyValue &get_call_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     AnyValue thisArg = Constants::UNDEFINED;
+                                                     std::span<const AnyValue> fnArgs;
+
+                                                     if (!args.empty())
+                                                     {
+                                                         thisArg = args[0];
+                                                         fnArgs = args.subspan(1);
+                                                     }
+
+                                                     return thisVal.call(thisArg, fnArgs); },
+                                                 "call");
+    return fn;
+}
+
+std::optional<AnyValue> get(const std::string &key)
+{
+    if (key == "toString") return get_toString_fn();
+    if (key == "call") return get_call_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();
+    if (key == "call") return get_call_fn();
+    return std::nullopt;
+}
+
+} // namespace FunctionPrototypes
+
+} // namespace jspp

package/src/prelude/values/function.hpp

@@ -13,6 +13,7 @@ namespace jspp
     JsFunctionCallable callable;
     std::optional<std::string> name;
     std::unordered_map<std::string, AnyValue> props;
+    std::map<AnyValue, AnyValue> symbol_props;
     AnyValue proto;
     bool is_generator;
     bool is_async;
@@ -23,34 +24,18 @@ namespace jspp
     JsFunction(const JsFunctionCallable &c,
                std::optional<std::string> n = std::nullopt,
                std::unordered_map<std::string, AnyValue> p = {},
+               std::map<AnyValue, AnyValue> sp = {},
                bool is_cls = false,
-               bool is_ctor = true)
-        : callable(c),
-          name(std::move(n)),
-          props(std::move(p)),
-          is_generator(callable.index() == 1),
-          is_async(callable.index() == 2),
-          is_class(is_cls),
-          is_constructor(is_ctor && !is_generator && !is_async) // Generators and asyncs are never constructors
-    {
-    }
+               bool is_ctor = true);
 
     // ---- Constructor B: explicit generator flag (backward compat) ----
     JsFunction(const JsFunctionCallable &c,
                bool is_gen,
                std::optional<std::string> n = std::nullopt,
                std::unordered_map<std::string, AnyValue> p = {},
+               std::map<AnyValue, AnyValue> sp = {},
                bool is_cls = false,
-               bool is_ctor = true)
-        : callable(c),
-          name(std::move(n)),
-          props(std::move(p)),
-          is_generator(is_gen),
-          is_async(callable.index() == 2),
-          is_class(is_cls),
-          is_constructor(is_ctor && !is_gen && !is_async)
-    {
-    }
+               bool is_ctor = true);
 
     // ---- Constructor C: explicit async flag ----
     JsFunction(const JsFunctionCallable &c,
@@ -58,17 +43,9 @@ namespace jspp
                bool is_async_func,
                std::optional<std::string> n = std::nullopt,
                std::unordered_map<std::string, AnyValue> p = {},
+               std::map<AnyValue, AnyValue> sp = {},
                bool is_cls = false,
-               bool is_ctor = true)
-        : callable(c),
-          name(std::move(n)),
-          props(std::move(p)),
-          is_generator(is_gen),
-          is_async(is_async_func),
-          is_class(is_cls),
-          is_constructor(is_ctor && !is_gen && !is_async_func)
-    {
-    }
+               bool is_ctor = true);
 
     JsType get_heap_type() const override { return JsType::Function; }
 
@@ -76,7 +53,10 @@ namespace jspp
     AnyValue call(AnyValue thisVal, std::span<const AnyValue> args);
 
     bool has_property(const std::string &key) const;
+    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/iterator.cpp

@@ -0,0 +1,309 @@
+#include "jspp.hpp"
+#include "values/iterator.hpp"
+#include "values/prototypes/iterator.hpp"
+
+namespace jspp {
+
+template <typename T>
+JsIterator<T>::JsIterator(handle_type h) : handle(h) {}
+
+template <typename T>
+JsIterator<T>::JsIterator(JsIterator &&other) noexcept 
+    : handle(std::exchange(other.handle, nullptr)),
+      props(std::move(other.props)),
+      symbol_props(std::move(other.symbol_props)) {}
+
+template <typename T>
+JsIterator<T>::~JsIterator() { if (handle) handle.destroy(); }
+
+template <typename T>
+JsIterator<T> JsIterator<T>::promise_type::get_return_object() {
+    return JsIterator{std::coroutine_handle<promise_type>::from_promise(*this)};
+}
+
+template <typename T>
+std::suspend_always JsIterator<T>::promise_type::initial_suspend() noexcept { return {}; }
+
+template <typename T>
+std::suspend_always JsIterator<T>::promise_type::final_suspend() noexcept { return {}; }
+
+template <typename T>
+void JsIterator<T>::promise_type::unhandled_exception() {
+    try {
+        throw;
+    } catch (const GeneratorReturnException&) {
+    } catch (...) {
+        exception_ = std::current_exception();
+    }
+}
+
+template <typename T>
+std::string JsIterator<T>::to_std_string() const { return "[object Generator]"; }
+
+template <typename T>
+typename JsIterator<T>::NextResult JsIterator<T>::next(const T &val)
+{
+    if (!handle || handle.done()) return {std::nullopt, true};
+    handle.promise().input_value = val;
+    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>
+typename JsIterator<T>::NextResult 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 JsIterator<T>::NextResult 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> JsIterator<T>::to_vector()
+{
+    std::vector<T> result;
+    while (true) {
+        auto next_res = this->next();
+        if (next_res.done) break;
+        result.push_back(next_res.value.value_or(Constants::UNDEFINED));
+    }
+    return result;
+}
+
+template <typename T>
+bool JsIterator<T>::has_symbol_property(const AnyValue &key) const { return symbol_props.count(key) > 0; }
+
+template <typename T>
+AnyValue JsIterator<T>::get_property(const std::string &key, AnyValue thisVal)
+{
+    auto it = props.find(key);
+    if (it == props.end()) {
+        if constexpr (std::is_same_v<T, AnyValue>) {
+            auto proto_it = IteratorPrototypes::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(it->second, thisVal, key);
+}
+
+template <typename T>
+AnyValue JsIterator<T>::get_symbol_property(const AnyValue &key, AnyValue thisVal)
+{
+    auto it = symbol_props.find(key);
+    if (it == symbol_props.end()) {
+        if constexpr (std::is_same_v<T, AnyValue>) {
+            auto proto_it = IteratorPrototypes::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());
+}
+
+template <typename T>
+AnyValue JsIterator<T>::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
+{
+    if constexpr (std::is_same_v<T, AnyValue>) {
+        auto proto_it = IteratorPrototypes::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);
+        }
+    }
+    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; }
+}
+
+template <typename T>
+AnyValue JsIterator<T>::set_symbol_property(const AnyValue &key, AnyValue value, 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; }
+}
+
+// Explicit template instantiation
+template class JsIterator<AnyValue>;
+
+namespace IteratorPrototypes {
+
+AnyValue &get_toString_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                 { return AnyValue::make_string(thisVal.as_iterator()->to_std_string()); },
+                                                 "toString");
+    return fn;
+}
+
+AnyValue &get_iterator_fn()
+{
+    static AnyValue fn = AnyValue::make_generator([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                  { return thisVal; },
+                                                  "Symbol.iterator");
+    return fn;
+}
+
+AnyValue &get_next_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
+                                                     auto res = thisVal.as_iterator()->next(val);
+                                                     return AnyValue::make_object({{"value", res.value.value_or(Constants::UNDEFINED)}, {"done", AnyValue::make_boolean(res.done)}}); },
+                                                 "next");
+    return fn;
+}
+
+AnyValue &get_return_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
+                                                     auto res = thisVal.as_iterator()->return_(val);
+                                                     return AnyValue::make_object({{"value", res.value.value_or(Constants::UNDEFINED)}, {"done", AnyValue::make_boolean(res.done)}}); },
+                                                 "return");
+    return fn;
+}
+
+AnyValue &get_throw_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     AnyValue err = args.empty() ? Constants::UNDEFINED : args[0];
+                                                     auto res = thisVal.as_iterator()->throw_(err);
+                                                     return AnyValue::make_object({{"value", res.value.value_or(Constants::UNDEFINED)}, {"done", AnyValue::make_boolean(res.done)}}); },
+                                                 "throw");
+    return fn;
+}
+
+AnyValue &get_toArray_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                 { return AnyValue::make_array(thisVal.as_iterator()->to_vector()); },
+                                                 "toArray");
+    return fn;
+}
+
+AnyValue &get_drop_fn()
+{
+    static AnyValue fn = AnyValue::make_generator([](AnyValue thisVal, std::vector<AnyValue> args) -> JsIterator<AnyValue>
+                                                  { 
+                                                    auto self = thisVal.as_iterator();
+                                                    size_t skip_count = 0;
+                                                    if (!args.empty()) {
+                                                        skip_count = static_cast<size_t>(args[0].as_double());
+                                                    }
+                                                    size_t skipped = 0;
+                                                    while (true)
+                                                    {
+                                                        auto next_res = self->next();
+                                                        if (next_res.done) { break; }
+                                                        if (skipped < skip_count)
+                                                        {
+                                                            skipped++;
+                                                            continue;
+                                                        }
+                                                        co_yield next_res.value.value_or(Constants::UNDEFINED);
+                                                    }
+                                                    co_return jspp::Constants::UNDEFINED; },
+                                                  "drop");
+    return fn;
+}
+
+AnyValue &get_take_fn()
+{
+    static AnyValue fn = AnyValue::make_generator([](AnyValue thisVal, std::vector<AnyValue> args) -> JsIterator<AnyValue>
+                                                  { 
+                                                    auto self = thisVal.as_iterator();
+                                                    size_t take_count = 0;
+                                                    if (!args.empty()) {
+                                                        take_count = static_cast<size_t>(args[0].as_double());
+                                                    }
+                                                    size_t taken = 0;
+                                                    while (true)
+                                                    {
+                                                        auto next_res = self->next();
+                                                        if (next_res.done) { break; }
+                                                        if (taken < take_count)
+                                                        {
+                                                            taken++;
+                                                            co_yield next_res.value.value_or(Constants::UNDEFINED);
+                                                        }
+                                                        if (taken >= take_count) 
+                                                        { 
+                                                            self->return_();
+                                                            break; 
+                                                        }
+                                                    }
+                                                    co_return jspp::Constants::UNDEFINED; },
+                                                  "take");
+    return fn;
+}
+
+AnyValue &get_some_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 { 
+                                                    auto self = thisVal.as_iterator();
+                                                    if (args.empty() || !args[0].is_function()) throw Exception::make_exception("callback is not a function", "TypeError");
+                                                    auto callback = args[0].as_function();
+                                                    while (true)
+                                                    {
+                                                        auto next_res = self->next();
+                                                        if (next_res.done) { break; }
+                                                        if (is_truthy(callback->call(thisVal, std::span<const AnyValue>((const jspp::AnyValue[]){next_res.value.value_or(Constants::UNDEFINED)}, 1))))
+                                                        {
+                                                            self->return_();
+                                                            return Constants::TRUE;
+                                                        }
+                                                    }
+                                                    return jspp::Constants::FALSE; },
+                                                         "some");
+    return fn;
+}
+
+std::optional<AnyValue> get(const std::string &key)
+{
+    if (key == "toString") return get_toString_fn();
+    if (key == "next") return get_next_fn();
+    if (key == "return") return get_return_fn();
+    if (key == "throw") return get_throw_fn();
+    if (key == "toArray") return get_toArray_fn();
+    if (key == "drop") return get_drop_fn();
+    if (key == "take") return get_take_fn();
+    if (key == "some") return get_some_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();
+    if (key == AnyValue::from_symbol(WellKnownSymbols::iterator)) return get_iterator_fn();
+
+    return std::nullopt;
+}
+
+} // namespace IteratorPrototypes
+
+} // namespace jspp