@ugo-studio/jspp 0.3.0 → 0.3.1

package/src/prelude/library/timer.hpp

@@ -2,91 +2,15 @@
 
 #include "types.hpp"
 #include "any_value.hpp"
-#include "scheduler.hpp"
-#include "values/function.hpp"
-#include "exception.hpp"
 
-// setTimeout(callback, delay, ...args)
-inline auto setTimeout = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-    if (args.empty() || !args[0].is_function()) {
-        throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
-    }
-    
-    auto callback = args[0];
-    double delay = 0;
-    if (args.size() > 1 && args[1].is_number()) {
-        delay = args[1].as_double();
-    }
-    
-    // Capture arguments
-    std::vector<jspp::AnyValue> callArgs;
-    for (size_t i = 2; i < args.size(); ++i) {
-        callArgs.push_back(args[i]);
-    }
-
-    auto task = [callback, callArgs]() {
-         try {
-             callback.call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(callArgs));
-         } catch (const jspp::Exception& e) {
-             std::cerr << "Uncaught exception in setTimeout: " << e.what() << "\n";
-         } catch (const std::exception& e) {
-             std::cerr << "Uncaught exception in setTimeout: " << e.what() << "\n";
-         } catch (...) {
-             std::cerr << "Uncaught unknown exception in setTimeout\n";
-         }
-    };
-
-    size_t id = jspp::Scheduler::instance().set_timeout(task, static_cast<size_t>(delay));
-    return jspp::AnyValue::make_number(static_cast<double>(id));
-}, "setTimeout");
-
-// clearTimeout(id)
-inline auto clearTimeout = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-    if (!args.empty() && args[0].is_number()) {
-        size_t id = static_cast<size_t>(args[0].as_double());
-        jspp::Scheduler::instance().clear_timer(id);
-    }
-    return jspp::Constants::UNDEFINED;
-}, "clearTimeout");
-
-// setInterval(callback, delay, ...args)
-inline auto setInterval = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-    if (args.empty() || !args[0].is_function()) {
-        throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
-    }
-    
-    auto callback = args[0];
-    double delay = 0;
-    if (args.size() > 1 && args[1].is_number()) {
-        delay = args[1].as_double();
-    }
-    
-    std::vector<jspp::AnyValue> callArgs;
-    for (size_t i = 2; i < args.size(); ++i) {
-        callArgs.push_back(args[i]);
-    }
-
-    auto task = [callback, callArgs]() {
-         try {
-             callback.call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(callArgs));
-         } catch (const jspp::Exception& e) {
-             std::cerr << "Uncaught exception in setInterval: " << e.what() << "\n";
-         } catch (const std::exception& e) {
-             std::cerr << "Uncaught exception in setInterval: " << e.what() << "\n";
-         } catch (...) {
-             std::cerr << "Uncaught unknown exception in setInterval\n";
-         }
-    };
-
-    size_t id = jspp::Scheduler::instance().set_interval(task, static_cast<size_t>(delay));
-    return jspp::AnyValue::make_number(static_cast<double>(id));
-}, "setInterval");
-
-// clearInterval(id)
-inline auto clearInterval = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-    if (!args.empty() && args[0].is_number()) {
-        size_t id = static_cast<size_t>(args[0].as_double());
-        jspp::Scheduler::instance().clear_timer(id);
-    }
-    return jspp::Constants::UNDEFINED;
-}, "clearInterval");
+namespace jspp {
+    extern AnyValue setTimeout;
+    extern AnyValue clearTimeout;
+    extern AnyValue setInterval;
+    extern AnyValue clearInterval;
+}
+
+using jspp::setTimeout;
+using jspp::clearTimeout;
+using jspp::setInterval;
+using jspp::clearInterval;

package/src/prelude/runtime.cpp

@@ -0,0 +1,19 @@
+#include "jspp.hpp"
+
+// Include core headers
+#include "values/iterator.hpp"
+#include "values/async_iterator.hpp"
+#include "values/string.hpp"
+#include "values/object.hpp"
+#include "values/array.hpp"
+#include "values/function.hpp"
+#include "values/promise.hpp"
+#include "values/symbol.hpp"
+#include "values/descriptors.hpp"
+#include "exception.hpp"
+
+namespace jspp {
+    // Explicit template instantiation definitions
+    template class JsIterator<AnyValue>;
+    template class JsAsyncIterator<AnyValue>;
+}

package/src/prelude/types.hpp

@@ -94,9 +94,6 @@ namespace jspp
         std::function<JsPromise(AnyValue, std::vector<AnyValue>)>,
         std::function<JsAsyncIterator<AnyValue>(AnyValue, std::vector<AnyValue>)>>;
 
-    // Awaiter for AnyValue
-    struct AnyValueAwaiter;
-
     // Truthiness checker
     const bool is_truthy(const double &val) noexcept;
     const bool is_truthy(const std::string &val) noexcept;
@@ -146,34 +143,42 @@ namespace jspp
     // AnyValue prototypes
     namespace ObjectPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
     namespace StringPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
     namespace NumberPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
     namespace ArrayPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
     namespace FunctionPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
     namespace PromisePrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
     namespace IteratorPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
     namespace SymbolPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
-}
+}

package/src/prelude/utils/access.hpp

@@ -83,9 +83,9 @@ namespace jspp
         }
 
         // Helper function to get enumerable own property keys/values of an object
-        inline std::vector<std::string> get_object_keys(const AnyValue &obj, bool include_symbols = false)
+        inline std::vector<AnyValue> get_object_keys(const AnyValue &obj, bool include_symbols = false)
         {
-            std::vector<std::string> keys;
+            std::vector<AnyValue> keys;
 
             if (obj.is_object())
             {
@@ -95,9 +95,6 @@ namespace jspp
                     if (ptr->deleted_keys.count(key))
                         continue;
 
-                    if (!include_symbols && JsSymbol::is_internal_key(key))
-                        continue;
-
                     auto offset_opt = ptr->shape->get_offset(key);
                     if (!offset_opt.has_value())
                         continue;
@@ -107,16 +104,37 @@ namespace jspp
                     if (val.is_data_descriptor())
                     {
                         if (val.as_data_descriptor()->enumerable)
-                            keys.push_back(key);
+                            keys.push_back(AnyValue::make_string(key));
                     }
                     else if (val.is_accessor_descriptor())
                     {
                         if (val.as_accessor_descriptor()->enumerable)
-                            keys.push_back(key);
+                            keys.push_back(AnyValue::make_string(key));
                     }
                     else
                     {
-                        keys.push_back(key);
+                        keys.push_back(AnyValue::make_string(key));
+                    }
+                }
+                if (include_symbols)
+                {
+                    for (const auto &pair : ptr->symbol_props)
+                    {
+                        const auto &val = pair.second;
+                        if (val.is_data_descriptor())
+                        {
+                            if (val.as_data_descriptor()->enumerable)
+                                keys.push_back(pair.first);
+                        }
+                        else if (val.is_accessor_descriptor())
+                        {
+                            if (val.as_accessor_descriptor()->enumerable)
+                                keys.push_back(pair.first);
+                        }
+                        else
+                        {
+                            keys.push_back(pair.first);
+                        }
                     }
                 }
             }
@@ -125,22 +143,62 @@ namespace jspp
                 auto ptr = obj.as_function();
                 for (const auto &pair : ptr->props)
                 {
-                    if (include_symbols || !JsSymbol::is_internal_key(pair.first))
+                    if (!pair.second.is_data_descriptor() && !pair.second.is_accessor_descriptor())
+                        keys.push_back(AnyValue::make_string(pair.first));
+                    else if ((pair.second.is_data_descriptor() && pair.second.as_data_descriptor()->enumerable) ||
+                             (pair.second.is_accessor_descriptor() && pair.second.as_accessor_descriptor()->enumerable))
+                        keys.push_back(AnyValue::make_string(pair.first));
+                }
+                if (include_symbols)
+                {
+                    for (const auto &pair : ptr->symbol_props)
                     {
-                        if (!pair.second.is_data_descriptor() && !pair.second.is_accessor_descriptor())
-                            keys.push_back(pair.first);
-                        else if ((pair.second.is_data_descriptor() && pair.second.as_data_descriptor()->enumerable) ||
-                                 (pair.second.is_accessor_descriptor() && pair.second.as_accessor_descriptor()->enumerable))
+                        const auto &val = pair.second;
+                        if (val.is_data_descriptor())
+                        {
+                            if (val.as_data_descriptor()->enumerable)
+                                keys.push_back(pair.first);
+                        }
+                        else if (val.is_accessor_descriptor())
+                        {
+                            if (val.as_accessor_descriptor()->enumerable)
+                                keys.push_back(pair.first);
+                        }
+                        else
+                        {
                             keys.push_back(pair.first);
+                        }
                     }
                 }
             }
             if (obj.is_array())
             {
-                auto len = obj.as_array()->length;
+                auto ptr = obj.as_array();
+                auto len = ptr->length;
                 for (uint64_t i = 0; i < len; ++i)
                 {
-                    keys.push_back(std::to_string(i));
+                    keys.push_back(AnyValue::make_string(std::to_string(i)));
+                }
+                if (include_symbols)
+                {
+                    for (const auto &pair : ptr->symbol_props)
+                    {
+                        const auto &val = pair.second;
+                        if (val.is_data_descriptor())
+                        {
+                            if (val.as_data_descriptor()->enumerable)
+                                keys.push_back(pair.first);
+                        }
+                        else if (val.is_accessor_descriptor())
+                        {
+                            if (val.as_accessor_descriptor()->enumerable)
+                                keys.push_back(pair.first);
+                        }
+                        else
+                        {
+                            keys.push_back(pair.first);
+                        }
+                    }
                 }
             }
             if (obj.is_string())
@@ -148,24 +206,30 @@ namespace jspp
                 auto len = obj.as_string()->value.length();
                 for (size_t i = 0; i < len; ++i)
                 {
-                    keys.push_back(std::to_string(i));
+                    keys.push_back(AnyValue::make_string(std::to_string(i)));
                 }
             }
 
             return keys;
         }
 
-        inline AnyValue get_object_iterator(const AnyValue &obj, const std::string &name)
+        inline AnyValue get_object_iterator(const AnyValue &obj, const std::optional<std::string> &name = std::nullopt)
         {
+            if (obj.is_null() || obj.is_undefined())
+            {
+                throw jspp::Exception::make_exception("Cannot read properties of " + obj.to_std_string() + " (reading 'Symbol.iterator')", "TypeError");
+            }
+
             if (obj.is_iterator())
             {
                 return obj;
             }
 
-            auto gen_fn = obj.get_own_property(WellKnownSymbols::iterator->key);
+            auto iterSym = AnyValue::from_symbol(WellKnownSymbols::iterator);
+            auto gen_fn = obj.get_own_property(iterSym);
             if (gen_fn.is_function())
             {
-                auto iter = gen_fn.call(obj, {}, WellKnownSymbols::iterator->key);
+                auto iter = gen_fn.call(obj, {}, iterSym.to_std_string());
                 if (iter.is_iterator())
                 {
                     return iter;
@@ -180,31 +244,38 @@ namespace jspp
                 }
             }
 
-            throw jspp::Exception::make_exception(name + " is not iterable", "TypeError");
+            throw jspp::Exception::make_exception(name.value_or(obj.to_std_string()) + " is not iterable", "TypeError");
         }
 
-        inline AnyValue get_object_async_iterator(const AnyValue &obj, const std::string &name)
+        inline AnyValue get_object_async_iterator(const AnyValue &obj, const std::optional<std::string> &name = std::nullopt)
         {
+            if (obj.is_null() || obj.is_undefined())
+            {
+                throw jspp::Exception::make_exception("Cannot read properties of " + obj.to_std_string() + " (reading 'Symbol.asyncIterator')", "TypeError");
+            }
+
             if (obj.is_async_iterator())
                 return obj;
 
-            auto method = obj.get_own_property(WellKnownSymbols::asyncIterator->key);
+            auto asyncIterSym = AnyValue::from_symbol(WellKnownSymbols::asyncIterator);
+            auto method = obj.get_own_property(asyncIterSym);
             if (method.is_function())
             {
-                auto iter = method.call(obj, {}, WellKnownSymbols::asyncIterator->key);
+                auto iter = method.call(obj, {}, asyncIterSym.to_std_string());
                 if (iter.is_object() || iter.is_async_iterator() || iter.is_iterator())
                     return iter;
             }
 
-            auto syncMethod = obj.get_own_property(WellKnownSymbols::iterator->key);
+            auto iterSym = AnyValue::from_symbol(WellKnownSymbols::iterator);
+            auto syncMethod = obj.get_own_property(iterSym);
             if (syncMethod.is_function())
             {
-                auto iter = syncMethod.call(obj, {}, WellKnownSymbols::iterator->key);
+                auto iter = syncMethod.call(obj, {}, iterSym.to_std_string());
                 if (iter.is_object() || iter.is_iterator())
                     return iter;
             }
 
-            throw jspp::Exception::make_exception(name + " is not async iterable", "TypeError");
+            throw jspp::Exception::make_exception(name.value_or(obj.to_std_string()) + " is not async iterable", "TypeError");
         }
 
         inline AnyValue in(const AnyValue &lhs, const AnyValue &rhs)
@@ -249,6 +320,10 @@ namespace jspp
                 {
                     proto = current.as_function()->proto;
                 }
+                else if (current.is_promise())
+                {
+                    proto = current.as_promise()->get_property("__proto__", current); // Fallback for promise if not fully modularized
+                }
                 else
                 {
                     break;
@@ -386,24 +461,40 @@ namespace jspp
             auto keys = get_object_keys(source);
             for (const auto &key : keys)
             {
-                target.set_own_property(key, source.get_property_with_receiver(key, source));
+                target.set_own_property(key, source.get_property_with_receiver(key.to_std_string(), source));
             }
         }
 
-        inline AnyValue get_rest_object(const AnyValue &source, const std::vector<std::string> &excluded_keys)
+        inline AnyValue get_rest_object(const AnyValue &source, const std::vector<AnyValue> &excluded_keys)
         {
             if (source.is_null() || source.is_undefined())
                 return AnyValue::make_object({});
 
             auto result = AnyValue::make_object({});
             auto keys = get_object_keys(source, true);
-            std::unordered_set<std::string> excluded(excluded_keys.begin(), excluded_keys.end());
+
+            auto is_excluded = [&](const AnyValue &key)
+            {
+                for (const auto &ex : excluded_keys)
+                {
+                    if (is_strictly_equal_to_primitive(key, ex))
+                        return true;
+                }
+                return false;
+            };
 
             for (const auto &key : keys)
             {
-                if (excluded.find(key) == excluded.end())
+                if (!is_excluded(key))
                 {
-                    result.set_own_property(key, source.get_property_with_receiver(key, source));
+                    if (key.is_symbol())
+                    {
+                        result.set_own_symbol_property(key, source.get_symbol_property_with_receiver(key, source));
+                    }
+                    else
+                    {
+                        result.set_own_property(key.to_std_string(), source.get_property_with_receiver(key.to_std_string(), source));
+                    }
                 }
             }
             return result;

package/src/prelude/utils/assignment_operators.hpp

@@ -1,99 +1,99 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-#include "utils/operators.hpp"
-
-namespace jspp {
-
-    // --- FRIEND IMPLEMENTATIONS ---
-
-    inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::add(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::sub(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::mul(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::div(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs) {
-        lhs = jspp::mod(lhs, rhs);
-        return lhs;
-    }
-
-    inline AnyValue &operator++(AnyValue &val) {
-        val = jspp::add(val, 1.0);
-        return val;
-    }
-
-    inline AnyValue operator++(AnyValue &val, int) {
-        AnyValue temp = val;
-        val = jspp::add(val, 1.0);
-        return temp;
-    }
-
-    inline AnyValue &operator--(AnyValue &val) {
-        val = jspp::sub(val, 1.0);
-        return val;
-    }
-
-    inline AnyValue operator--(AnyValue &val, int) {
-        AnyValue temp = val;
-        val = jspp::sub(val, 1.0);
-        return temp;
-    }
-
-    // --- OVERLOADS FOR PRIMITIVES ---
-
-    inline AnyValue &operator+=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::add(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator+=(AnyValue &lhs, const int &rhs) {
-        return lhs += static_cast<double>(rhs);
-    }
-
-    inline AnyValue &operator-=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::sub(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator-=(AnyValue &lhs, const int &rhs) {
-        return lhs -= static_cast<double>(rhs);
-    }
-
-    inline AnyValue &operator*=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::mul(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator*=(AnyValue &lhs, const int &rhs) {
-        return lhs *= static_cast<double>(rhs);
-    }
-
-    inline AnyValue &operator/=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::div(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator/=(AnyValue &lhs, const int &rhs) {
-        return lhs /= static_cast<double>(rhs);
-    }
-
-    inline AnyValue &operator%=(AnyValue &lhs, const double &rhs) {
-        lhs = jspp::mod(lhs, rhs);
-        return lhs;
-    }
-    inline AnyValue &operator%=(AnyValue &lhs, const int &rhs) {
-        return lhs %= static_cast<double>(rhs);
-    }
-}
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp {
+
+    // --- FRIEND IMPLEMENTATIONS ---
+
+    inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = jspp::add(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = jspp::sub(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = jspp::mul(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = jspp::div(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = jspp::mod(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator++(AnyValue &val) {
+        val = jspp::add(val, 1.0);
+        return val;
+    }
+
+    inline AnyValue operator++(AnyValue &val, int) {
+        AnyValue temp = val;
+        val = jspp::add(val, 1.0);
+        return temp;
+    }
+
+    inline AnyValue &operator--(AnyValue &val) {
+        val = jspp::sub(val, 1.0);
+        return val;
+    }
+
+    inline AnyValue operator--(AnyValue &val, int) {
+        AnyValue temp = val;
+        val = jspp::sub(val, 1.0);
+        return temp;
+    }
+
+    // --- OVERLOADS FOR PRIMITIVES ---
+
+    inline AnyValue &operator+=(AnyValue &lhs, const double &rhs) {
+        lhs = jspp::add(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator+=(AnyValue &lhs, const int &rhs) {
+        return lhs += static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator-=(AnyValue &lhs, const double &rhs) {
+        lhs = jspp::sub(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator-=(AnyValue &lhs, const int &rhs) {
+        return lhs -= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator*=(AnyValue &lhs, const double &rhs) {
+        lhs = jspp::mul(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator*=(AnyValue &lhs, const int &rhs) {
+        return lhs *= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator/=(AnyValue &lhs, const double &rhs) {
+        lhs = jspp::div(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator/=(AnyValue &lhs, const int &rhs) {
+        return lhs /= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator%=(AnyValue &lhs, const double &rhs) {
+        lhs = jspp::mod(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator%=(AnyValue &lhs, const int &rhs) {
+        return lhs %= static_cast<double>(rhs);
+    }
+}