@ugo-studio/jspp 0.1.8 → 0.2.0

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

@@ -42,7 +42,7 @@ namespace jspp
                 {
                     if (args.empty())
                     {
-                        return AnyValue::make_undefined();
+                        return Constants::UNDEFINED;
                     }
 
                     const auto &new_len_val = args[0];
@@ -103,7 +103,7 @@ namespace jspp
                                                {
                                                                                            if (self->length == 0)
                                                                                            {
-                                                                                               return AnyValue::make_undefined();
+                                                                                               return Constants::UNDEFINED;
                                                                                            }
                                                                                            uint64_t last_idx = self->length - 1;
                                                                                            AnyValue last_val = self->get_property(static_cast<uint32_t>(last_idx));
@@ -128,7 +128,7 @@ namespace jspp
                                                {
                                                                                            if (self->length == 0)
                                                                                            {
-                                                                                               return AnyValue::make_undefined();
+                                                                                               return Constants::UNDEFINED;
                                                                                            }
                                                                                            AnyValue first_val = self->get_property(0u);
 
@@ -227,7 +227,7 @@ namespace jspp
                                                                                                    callback->call(thisVal, cbArgs);
                                                                                                }
                                                                                            }
-                                                                                           return AnyValue::make_undefined(); },
+                                                                                           return Constants::UNDEFINED; },
                                                key);
             }
 
@@ -241,7 +241,7 @@ namespace jspp
                     double k;
                     if (relativeIndex >= 0) k = relativeIndex;
                     else k = len + relativeIndex;
-                    if (k < 0 || k >= len) return AnyValue::make_undefined();
+                    if (k < 0 || k >= len) return Constants::UNDEFINED;
                     return self->get_property(static_cast<uint32_t>(k)); },
                                                key);
             }
@@ -251,9 +251,9 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    AnyValue searchElement = args.empty() ? AnyValue::make_undefined() : args[0];
+                    AnyValue searchElement = args.empty() ? Constants::UNDEFINED : args[0];
                     double len = static_cast<double>(self->length);
-                    if (len == 0) return AnyValue::make_boolean(false);
+                    if (len == 0) return Constants::FALSE;
                     double n = (args.size() > 1) ? Operators_Private::ToNumber(args[1]) : 0;
                     double k;
                     if (n >= 0) k = n;
@@ -264,10 +264,10 @@ namespace jspp
                     {
                         AnyValue element = self->get_property(static_cast<uint32_t>(i));
                         // SameValueZero algorithm (includes handles NaN)
-                        if (element.is_number() && searchElement.is_number() && std::isnan(element.as_double()) && std::isnan(searchElement.as_double())) return AnyValue::make_boolean(true);
-                        if (is_strictly_equal_to_primitive(element, searchElement)) return AnyValue::make_boolean(true);
+                        if (element.is_number() && searchElement.is_number() && std::isnan(element.as_double()) && std::isnan(searchElement.as_double())) return Constants::TRUE;
+                        if (is_strictly_equal_to_primitive(element, searchElement)) return Constants::TRUE;
                     }
-                    return AnyValue::make_boolean(false); },
+                    return Constants::FALSE; },
                                                key);
             }
 
@@ -276,7 +276,7 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    AnyValue searchElement = args.empty() ? AnyValue::make_undefined() : args[0];
+                    AnyValue searchElement = args.empty() ? Constants::UNDEFINED : args[0];
                     double len = static_cast<double>(self->length);
                     if (len == 0) return AnyValue::make_number(-1);
                     double n = (args.size() > 1) ? Operators_Private::ToNumber(args[1]) : 0;
@@ -301,7 +301,7 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    AnyValue searchElement = args.empty() ? AnyValue::make_undefined() : args[0];
+                    AnyValue searchElement = args.empty() ? Constants::UNDEFINED : args[0];
                     double len = static_cast<double>(self->length);
                     if (len == 0) return AnyValue::make_number(-1);
                     double n = (args.size() > 1) ? Operators_Private::ToNumber(args[1]) : len - 1;
@@ -341,7 +341,7 @@ namespace jspp
                             return element;
                         }
                     }
-                    return AnyValue::make_undefined(); },
+                    return Constants::UNDEFINED; },
                                                key);
             }
 
@@ -387,7 +387,7 @@ namespace jspp
                             return element;
                         }
                     }
-                    return AnyValue::make_undefined(); },
+                    return Constants::UNDEFINED; },
                                                key);
             }
 
@@ -431,7 +431,7 @@ namespace jspp
                                                     for (uint64_t i = 0; i < self->length; ++i) {
                                                         co_yield AnyValue::make_number(i);
                                                     }
-                                                    co_return AnyValue::make_undefined(); },
+                                                    co_return Constants::UNDEFINED; },
                                                 key);
             }
 
@@ -447,7 +447,7 @@ namespace jspp
                                                         entry.push_back(self->get_property(static_cast<uint32_t>(i)));
                                                         co_yield AnyValue::make_array(std::move(entry));
                                                     }
-                                                    co_return AnyValue::make_undefined(); },
+                                                    co_return Constants::UNDEFINED; },
                                                 key);
             }
 
@@ -517,11 +517,11 @@ namespace jspp
                             AnyValue kVal = AnyValue::make_number(i);
                             const AnyValue cbArgs[] = {val, kVal, thisVal};
                             if (!is_truthy(callback->call(thisArg, std::span<const AnyValue>(cbArgs, 3)))) {
-                                return AnyValue::make_boolean(false);
+                                return Constants::FALSE;
                             }
                         }
                     }
-                    return AnyValue::make_boolean(true); },
+                    return Constants::TRUE; },
                                                key);
             }
 
@@ -540,11 +540,11 @@ namespace jspp
                             AnyValue kVal = AnyValue::make_number(i);
                             const AnyValue cbArgs[] = {val, kVal, thisVal};
                             if (is_truthy(callback->call(thisArg, std::span<const AnyValue>(cbArgs, 3)))) {
-                                return AnyValue::make_boolean(true);
+                                return Constants::TRUE;
                             }
                         }
                     }
-                    return AnyValue::make_boolean(false); },
+                    return Constants::FALSE; },
                                                key);
             }
 
@@ -698,7 +698,7 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    AnyValue value = args.empty() ? AnyValue::make_undefined() : args[0];
+                    AnyValue value = args.empty() ? Constants::UNDEFINED : args[0];
                     double len = static_cast<double>(self->length);
                     double start = (args.size() > 1) ? Operators_Private::ToNumber(args[1]) : 0;
                     double end = (args.size() > 2 && !args[2].is_undefined()) ? Operators_Private::ToNumber(args[2]) : len;
@@ -755,7 +755,7 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    AnyValue compareFn = args.empty() ? AnyValue::make_undefined() : args[0];
+                    AnyValue compareFn = args.empty() ? Constants::UNDEFINED : args[0];
                     
                     std::vector<AnyValue> items;
                     for (uint64_t i = 0; i < self->length; ++i) {

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

@@ -20,17 +20,10 @@ namespace jspp
                                                key);
             }
             // --- [Symbol.asyncIterator]() method ---
-            // For async iterators, the async iterator is itself (similar to sync iterators)
             if (key == WellKnownSymbols::asyncIterator->key)
             {
-                // We return 'this'. Since we can't easily create a shared_ptr from raw pointer,
-                // we rely on the context to hold the reference or implement better shared_from_this strategy.
-                // For now, assume it works like Iterator.
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                               { 
-                                                    // This is slightly dangerous as we create a new shared_ptr from raw.
-                                                    // TODO: fix lifetime management
-                                                    return thisVal; },
+                                               { return thisVal; },
                                                key);
             }
             // --- next() method ---
@@ -38,7 +31,7 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                                                AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
+                                                AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
                                                 auto res = self->next(val);
                                                 return AnyValue::make_promise(res); },
                                                key);
@@ -47,4 +40,4 @@ namespace jspp
             return std::nullopt;
         }
     }
-}
+}

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

@@ -1,58 +1,51 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/iterator.hpp"
-#include "any_value.hpp"
-#include "exception.hpp"
-#include "utils/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::toStringTag->key)
-            {
-                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const 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 AnyValue &thisVal, std::span<const 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 AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                               {
-                                                AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
-                                                auto res = self->next(val);
-                                                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 AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                               { return AnyValue::make_array(self->to_vector()); },
-                                               key);
-            }
-
-            return std::nullopt;
-        }
-    }
-}
+#pragma once
+
+#include "types.hpp"
+#include "values/iterator.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+#include "utils/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::toStringTag->key)
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const 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 AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                {
+                                                   return thisVal; },
+                                                key);
+            }
+            // --- next() method ---
+            if (key == "next")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                               {
+                                                AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
+                                                auto res = self->next(val);
+                                                return AnyValue::make_object({{"value",res.value.value_or(Constants::UNDEFINED)},{"done",AnyValue::make_boolean(res.done)},}); },
+                                               key);
+            }
+            // --- toArray() method ---
+            if (key == "toArray")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                               { return AnyValue::make_array(self->to_vector()); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

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

@@ -15,23 +15,32 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    AnyValue onFulfilled = (args.size() > 0 && args[0].is_function()) ? args[0] : AnyValue::make_undefined();
-                    AnyValue onRejected = (args.size() > 1 && args[1].is_function()) ? args[1] : AnyValue::make_undefined();
+                    AnyValue onFulfilled = (args.size() > 0 && args[0].is_function()) ? args[0] : Constants::UNDEFINED;
+                    AnyValue onRejected = (args.size() > 1 && args[1].is_function()) ? args[1] : Constants::UNDEFINED;
                     
                     // "then" returns a new Promise
                     JsPromise newPromise; 
                     AnyValue newPromiseVal = AnyValue::make_promise(newPromise);
                     
-                    // Capture shared pointer to the new promise's state to keep it alive and modify it
                     auto newPromiseState = newPromise.state; 
-                    // Helper wrapper to interact with state
                     auto resolveNew = [newPromiseState](const AnyValue& v) {
-                        JsPromise p; p.state = newPromiseState;
-                        p.resolve(v);
+                        // Manual state resolution to avoid HeapObject management issues here
+                        if (newPromiseState->status != PromiseStatus::Pending) return;
+                        newPromiseState->status = PromiseStatus::Fulfilled;
+                        newPromiseState->result = v;
+                        auto callbacks = newPromiseState->onFulfilled;
+                        newPromiseState->onFulfilled.clear();
+                        newPromiseState->onRejected.clear();
+                        for (auto& cb : callbacks) jspp::Scheduler::instance().enqueue([cb, v]() { cb(v); });
                     };
                     auto rejectNew = [newPromiseState](const AnyValue& r) {
-                        JsPromise p; p.state = newPromiseState;
-                        p.reject(r);
+                        if (newPromiseState->status != PromiseStatus::Pending) return;
+                        newPromiseState->status = PromiseStatus::Rejected;
+                        newPromiseState->result = r;
+                        auto callbacks = newPromiseState->onRejected;
+                        newPromiseState->onFulfilled.clear();
+                        newPromiseState->onRejected.clear();
+                        for (auto& cb : callbacks) jspp::Scheduler::instance().enqueue([cb, r]() { cb(r); });
                     };
 
 
@@ -40,9 +49,8 @@ namespace jspp
                         if (onFulfilled.is_function()) {
                             try {
                                 const AnyValue cbArgs[] = {val};
-                                auto res = onFulfilled.call(AnyValue::make_undefined(), cbArgs, "onFulfilled");
+                                auto res = onFulfilled.call(Constants::UNDEFINED, cbArgs, "onFulfilled");
                                 if (res.is_promise()) {
-                                    // Chaining: newPromise follows res
                                     auto chained = res.as_promise();
                                     chained->then(
                                         [resolveNew](const AnyValue& v) { resolveNew(v); },
@@ -52,12 +60,12 @@ namespace jspp
                                     resolveNew(res);
                                 }
                             } catch (const Exception& e) {
-                                rejectNew(*e.data);
+                                rejectNew(e.data);
                             } catch (...) {
                                 rejectNew(AnyValue::make_string("Unknown error"));
                             }
                         } else {
-                            resolveNew(val); // Fallthrough
+                            resolveNew(val);
                         }
                     };
 
@@ -66,7 +74,7 @@ namespace jspp
                          if (onRejected.is_function()) {
                             try {
                                 const AnyValue cbArgs[] = {reason};
-                                auto res = onRejected.call(AnyValue::make_undefined(), cbArgs,"onRejected");
+                                auto res = onRejected.call(Constants::UNDEFINED, cbArgs,"onRejected");
                                 if (res.is_promise()) {
                                     auto chained = res.as_promise();
                                     chained->then(
@@ -74,15 +82,15 @@ namespace jspp
                                         [rejectNew](const AnyValue& e) { rejectNew(e); }
                                     );
                                 } else {
-                                    resolveNew(res); // Recovered
+                                    resolveNew(res);
                                 }
                             } catch (const Exception& e) {
-                                rejectNew(*e.data);
+                                rejectNew(e.data);
                             } catch (...) {
                                 rejectNew(AnyValue::make_string("Unknown error"));
                             }
                         } else {
-                            rejectNew(reason); // Fallthrough
+                            rejectNew(reason);
                         }
                     };
 
@@ -94,9 +102,8 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    // catch(onRejected) is then(undefined, onRejected)
-                    AnyValue onRejected = (args.size() > 0 && args[0].is_function()) ? args[0] : AnyValue::make_undefined();
-                    const AnyValue thenArgs[] = {AnyValue::make_undefined(), onRejected};
+                    AnyValue onRejected = (args.size() > 0 && args[0].is_function()) ? args[0] : Constants::UNDEFINED;
+                    const AnyValue thenArgs[] = {Constants::UNDEFINED, onRejected};
                     return thisVal.get_own_property("then").call(thisVal, thenArgs,"then"); }, "catch");
             }
 
@@ -104,23 +111,20 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    AnyValue onFinally = (args.size() > 0 && args[0].is_function()) ? args[0] : AnyValue::make_undefined();
-                    
-                    // finally(onFinally) returns a promise that passes through value/reason, 
-                    // but executes onFinally first.
+                    AnyValue onFinally = (args.size() > 0 && args[0].is_function()) ? args[0] : Constants::UNDEFINED;
                     
                     const AnyValue thenArgs[] = {
                         AnyValue::make_function([onFinally](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
-                            AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
+                            AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
                             if (onFinally.is_function()) {
-                                onFinally.call(AnyValue::make_undefined(), {}, "onFinally");
+                                onFinally.call(Constants::UNDEFINED, {}, "onFinally");
                             }
                             return val;
                         }, ""),
                         AnyValue::make_function([onFinally](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
-                            AnyValue reason = args.empty() ? AnyValue::make_undefined() : args[0];
+                            AnyValue reason = args.empty() ? Constants::UNDEFINED : args[0];
                             if (onFinally.is_function()) {
-                                onFinally.call(AnyValue::make_undefined(), {}, "onFinally");
+                                onFinally.call(Constants::UNDEFINED, {}, "onFinally");
                             }
                             throw Exception(reason);
                         }, "")
@@ -131,4 +135,4 @@ namespace jspp
             return std::nullopt;
         }
     }
-}
+}

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

@@ -40,7 +40,7 @@ namespace jspp
                 return AnyValue::make_accessor_descriptor([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
                                                           { return AnyValue::make_number(self->value.length()); },
                                                           [self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                          { return AnyValue::make_undefined(); },
+                                                          { return Constants::UNDEFINED; },
                                                           false,
                                                           false);
             }
@@ -78,12 +78,12 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    if(args.empty()) return AnyValue::make_boolean(false);
+                    if(args.empty()) return Constants::FALSE;
                     std::string search = args[0].to_std_string();
                     size_t end_pos = (args.size() > 1 && !args[1].is_undefined()) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : self->value.length();
                     
                     if (end_pos > self->value.length()) end_pos = self->value.length();
-                    if (search.length() > end_pos) return AnyValue::make_boolean(false);
+                    if (search.length() > end_pos) return Constants::FALSE;
 
                     return AnyValue::make_boolean(self->value.substr(end_pos - search.length(), search.length()) == search); },
                                                key);
@@ -94,7 +94,7 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    if(args.empty()) return AnyValue::make_boolean(false);
+                    if(args.empty()) return Constants::FALSE;
                     std::string search = args[0].to_std_string();
                     size_t pos = (args.size() > 1) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : 0;
                     
@@ -269,7 +269,7 @@ namespace jspp
             {
                 return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
-                    if(args.empty()) return AnyValue::make_boolean(false);
+                    if(args.empty()) return Constants::FALSE;
                     std::string search = args[0].to_std_string();
                     size_t pos = (args.size() > 1) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : 0;
                     if (pos > self->value.length()) pos = self->value.length();

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

@@ -43,7 +43,7 @@ namespace jspp
                     {
                         if (self->description.empty())
                         {
-                            return AnyValue::make_undefined();
+                            return Constants::UNDEFINED;
                         }
                         return AnyValue::make_string(self->description);
                     },

package/src/prelude/values/string.hpp

@@ -9,13 +9,15 @@ namespace jspp
     // Forward declaration of AnyValue
     class AnyValue;
 
-    struct JsString
+    struct JsString : HeapObject
     {
         std::string value;
 
         JsString() = default;
         explicit JsString(const std::string &s) : value(s) {}
 
+        JsType get_heap_type() const override { return JsType::String; }
+
         std::string to_std_string() const;
         JsIterator<AnyValue> get_iterator();