@ugo-studio/jspp 0.3.0 → 0.3.1

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

@@ -1,254 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/promise.hpp"
-#include "any_value.hpp"
-#include "values/prototypes/promise.hpp"
-
-namespace jspp
-{
-
-    inline PromiseState::PromiseState() : result(Constants::UNDEFINED) {}
-
-    inline JsPromise::JsPromise() : state(std::make_shared<PromiseState>()) {}
-
-    inline void JsPromise::resolve(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())
-                    {
-                        // We can't easily use JsPromise here because it's a HeapObject now.
-                        // But we can manually resolve the state if we have a way.
-                        // Actually, we can create a temporary AnyValue from the state.
-                        // But AnyValue expects a JsPromise* which was allocated with new.
-                        // This is tricky.
-                        // Let's assume we can just modify the status and result of the state directly.
-                        s->status = PromiseStatus::Fulfilled;
-                        s->result = v;
-                        auto callbacks = s->onFulfilled;
-                        s->onFulfilled.clear();
-                        s->onRejected.clear();
-                        for (auto &cb : callbacks)
-                            jspp::Scheduler::instance().enqueue([cb, v]()
-                                                                { cb(v); });
-                    }
-                },
-                [weak_state](AnyValue r)
-                {
-                    if (auto s = weak_state.lock())
-                    {
-                        s->status = PromiseStatus::Rejected;
-                        s->result = r;
-                        auto callbacks = s->onRejected;
-                        s->onFulfilled.clear();
-                        s->onRejected.clear();
-                        for (auto &cb : callbacks)
-                            jspp::Scheduler::instance().enqueue([cb, r]()
-                                                                { cb(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(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 auto JsPromise::operator co_await() const
-    {
-        // This is safe because AnyValue::make_promise copies the JsPromise (which is a HeapObject)
-        // Actually, AnyValue::make_promise(const JsPromise&) does from_ptr(new JsPromise(promise)).
-        return AnyValueAwaiter{AnyValue::make_promise(*this)};
-    }
-
-    inline std::string JsPromise::to_std_string() const
-    {
-        return "[object Promise]";
-    }
-
-    inline AnyValue JsPromise::get_property(const std::string &key, AnyValue thisVal)
-    {
-        // Prototype lookup
-        auto proto_it = PromisePrototypes::get(key);
-        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 Constants::UNDEFINED;
-    }
-
-    inline AnyValue JsPromise::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
-    {
-        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(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(AnyValue value)
-    {
-        return AnyValueAwaiter{value};
-    }
-
-    inline auto JsPromisePromiseType::await_transform(const JsPromise &value)
-    {
-        // value is a JsPromise& which is a HeapObject.
-        // We wrap it in a temporary AnyValue for Awaiter.
-        // Wait, AnyValue::make_promise(value) will allocate a new JsPromise on heap.
-        // This is fine for now.
-        return AnyValueAwaiter{AnyValue::make_promise(value)};
-    }
-
-    // --- AnyValueAwaiter ---
-
-    inline bool AnyValueAwaiter::await_ready()
-    {
-        return false;
-    }
-
-    inline void AnyValueAwaiter::await_suspend(std::coroutine_handle<> h)
-    {
-        if (!value.is_promise())
-        {
-            jspp::Scheduler::instance().enqueue([h]() mutable
-                                                { h.resume(); });
-            return;
-        }
-        auto p = value.as_promise();
-
-        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(p->state->result);
-        }
-    }
-
-}

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

@@ -1,37 +0,0 @@
-#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"
-
-inline std::string jspp::JsString::to_std_string() const
-{
-    return value;
-}
-
-inline jspp::AnyValue jspp::JsString::get_property(const std::string &key, const AnyValue &thisVal)
-{
-    auto proto_fn = StringPrototypes::get(key);
-    if (proto_fn.has_value())
-    {
-        return AnyValue::resolve_property_for_read(proto_fn.value(), thisVal, key);
-    }
-    if (JsArray::is_array_index(key))
-    {
-        uint32_t idx = static_cast<uint32_t>(std::stoull(key));
-        return get_property(idx);
-    }
-    return Constants::UNDEFINED;
-}
-
-inline jspp::AnyValue jspp::JsString::get_property(uint32_t idx)
-{
-    if (idx < value.length())
-    {
-        return AnyValue::make_string(std::string(1, value[idx]));
-    }
-    return Constants::UNDEFINED;
-}

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

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/symbol.hpp"
-#include "any_value.hpp"
-#include "values/prototypes/symbol.hpp"
-
-inline std::string jspp::JsSymbol::to_std_string() const
-{
-    return "Symbol(" + description + ")";
-}
-
-inline jspp::AnyValue jspp::JsSymbol::get_property(const std::string &key, const AnyValue &thisVal)
-{
-    auto proto_it = SymbolPrototypes::get(key);
-    if (proto_it.has_value())
-    {
-        return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
-    }
-    return Constants::UNDEFINED;
-}