@ugo-studio/jspp 0.1.4 → 0.1.5

package/src/prelude/exception.hpp

@@ -1,6 +1,7 @@
 
 #pragma once
 
+#include <exception>
 #include "types.hpp"
 
 namespace jspp

package/src/prelude/exception_helpers.hpp

@@ -12,10 +12,10 @@ const char *jspp::Exception::what() const noexcept
 jspp::Exception jspp::Exception::make_exception(const std::string &message, const std::string &name = "Error")
 {
     // Use the global Error object to construct the exception
-    std::vector<AnyValue> args = { AnyValue::make_string(message) };
-    AnyValue errorObj = ::Error.construct(args);
-    errorObj.define_data_property("name", AnyValue::make_string(name));
-    
+    std::vector<AnyValue> args = {AnyValue::make_string(message)};
+    AnyValue errorObj = ::Error.construct(args, name);
+    errorObj.define_data_property("name", AnyValue::make_string(name), true, false, true);
+
     return Exception(errorObj);
 }
 jspp::AnyValue jspp::Exception::exception_to_any_value(const std::exception &ex)

package/src/prelude/index.hpp

@@ -4,6 +4,7 @@
 #include "utils/well_known_symbols.hpp"
 
 // values
+#include "values/shape.hpp"
 #include "values/symbol.hpp"
 #include "values/non_values.hpp"
 #include "values/object.hpp"
@@ -13,9 +14,8 @@
 #include "values/promise.hpp"
 #include "values/string.hpp"
 
-#include "exception.hpp"
-#include "values/descriptors.hpp"
 #include "any_value.hpp"
+#include "values/descriptors.hpp"
 #include "any_value_helpers.hpp"
 #include "any_value_access.hpp"
 #include "any_value_defines.hpp"
@@ -30,6 +30,7 @@
 #include "values/prototypes/iterator.hpp"
 #include "values/prototypes/promise.hpp"
 #include "values/prototypes/string.hpp"
+#include "values/prototypes/number.hpp"
 
 #include "values/helpers/symbol.hpp"
 #include "values/helpers/object.hpp"
@@ -41,12 +42,18 @@
 
 // utilities
 #include "utils/operators.hpp"
+#include "utils/assignment_operators.hpp"
 #include "utils/access.hpp"
 #include "utils/log_any_value/log_any_value.hpp"
 
 // js standard libraries
 #include "library/symbol.hpp"
+#include "library/process.hpp"
+#include "library/function.hpp"
 #include "library/console.hpp"
 #include "library/performance.hpp"
 #include "library/promise.hpp"
+#include "library/math.hpp"
+#include "library/object.hpp"
+#include "library/array.hpp"
 #include "library/global.hpp"

package/src/prelude/library/array.hpp

@@ -0,0 +1,190 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+#include "utils/access.hpp"
+
+inline auto Array = jspp::AnyValue::make_class([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                               {
+    if (args.size() == 1 && args[0].is_number()) {
+        double len = args[0].as_double();
+        if (len < 0 || len > 4294967295.0) { // Max uint32
+             throw jspp::Exception::make_exception("Invalid array length", "RangeError");
+        }
+        auto arr = jspp::AnyValue::make_array(std::vector<jspp::AnyValue>());
+        arr.as_array()->length = static_cast<uint64_t>(len);
+        arr.as_array()->dense.resize(static_cast<size_t>(len), jspp::AnyValue::make_uninitialized());
+        return arr;
+    }
+    std::vector<jspp::AnyValue> elements;
+    for(const auto& arg : args) {
+        elements.push_back(arg);
+    }
+    return jspp::AnyValue::make_array(std::move(elements)); }, "Array");
+
+struct ArrayInit
+{
+    ArrayInit()
+    {
+        // Set Array.prototype.proto to Object.prototype
+        // Array.get_own_property("prototype").set_prototype(::Object.get_own_property("prototype"));
+
+        // Array.isArray(value)
+        Array.define_data_property("isArray", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                            {
+            if (args.empty()) return jspp::Constants::FALSE;
+            return jspp::AnyValue::make_boolean(args[0].is_array()); }, "isArray"));
+
+        // Array.of(...elements)
+        Array.define_data_property("of", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                       {
+            std::vector<jspp::AnyValue> elements;
+            for(const auto& arg : args) {
+                elements.push_back(arg);
+            }
+            return jspp::AnyValue::make_array(std::move(elements)); }, "of"));
+
+        // Array.from(arrayLike, mapFn?, thisArg?)
+        Array.define_data_property("from", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                         {
+            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
+                throw jspp::Exception::make_exception("Array.from requires an array-like object", "TypeError");
+            }
+
+            const auto& items = args[0];
+            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
+            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
+
+            std::vector<jspp::AnyValue> result;
+
+            // Check if iterable
+            // Simple check: does it have [Symbol.iterator]?
+            auto iteratorSym = jspp::WellKnownSymbols::iterator;
+            if (items.has_property(iteratorSym->key)) {
+                auto iter = jspp::Access::get_object_value_iterator(items, "Array.from source");
+                auto nextFn = iter.get_own_property("next");
+                
+                size_t k = 0;
+                while (true) {
+                    auto nextRes = nextFn.call(iter, std::span<const jspp::AnyValue>{}, "next");
+                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
+                    
+                    auto val = nextRes.get_own_property("value");
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {val, kVal};
+                        val = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                    }
+                    result.push_back(val);
+                    k++;
+                }
+            } else {
+                // Array-like (length property)
+                auto lenVal = items.get_property_with_receiver("length", items);
+                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                
+                for (size_t k = 0; k < len; ++k) {
+                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
+                        kVal = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                    }
+                    result.push_back(kVal);
+                }
+            }
+            
+            return jspp::AnyValue::make_array(std::move(result)); }, "from"));
+
+        // Array.fromAsync(iterableOrArrayLike, mapFn?, thisArg?)
+        Array.define_data_property("fromAsync", jspp::AnyValue::make_async_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::JsPromise
+                                                                                    {
+            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
+                throw jspp::Exception::make_exception("Array.fromAsync requires an iterable or array-like object", "TypeError");
+            }
+
+            const auto& items = args[0];
+            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
+            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
+
+            std::vector<jspp::AnyValue> result;
+            
+            bool isAsync = false;
+            jspp::AnyValue iter;
+            jspp::AnyValue nextFn;
+
+            if (items.has_property(jspp::WellKnownSymbols::asyncIterator->key)) {
+                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::asyncIterator->key, items);
+                if (method.is_function()) {
+                    iter = method.call(items, {});
+                    nextFn = iter.get_own_property("next");
+                    isAsync = true;
+                }
+            } 
+            
+            if (!isAsync && items.has_property(jspp::WellKnownSymbols::iterator->key)) {
+                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::iterator->key, items);
+                if (method.is_function()) {
+                    iter = method.call(items, {});
+                    nextFn = iter.get_own_property("next");
+                }
+            }
+
+            if (!iter.is_undefined()) {
+                size_t k = 0;
+                while (true) {
+                    auto nextRes = nextFn.call(iter, {});
+                    
+                    if (nextRes.is_promise()) {
+                        nextRes = co_await nextRes;
+                    }
+                    
+                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
+                    
+                    auto val = nextRes.get_own_property("value");
+                    
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {val, kVal};
+                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                        if (mapRes.is_promise()) {
+                            val = co_await mapRes;
+                        } else {
+                            val = mapRes;
+                        }
+                    }
+                    result.push_back(val);
+                    k++;
+                }
+            } else {
+                auto lenVal = items.get_property_with_receiver("length", items);
+                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                
+                for (size_t k = 0; k < len; ++k) {
+                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
+                    if (kVal.is_promise()) {
+                        kVal = co_await kVal;
+                    }
+
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
+                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                        if (mapRes.is_promise()) {
+                            kVal = co_await mapRes;
+                        } else {
+                            kVal = mapRes;
+                        }
+                    }
+                    result.push_back(kVal);
+                }
+            }
+
+            co_return jspp::AnyValue::make_array(std::move(result)); }, "fromAsync"));
+
+        // Array[Symbol.species]
+        Array.define_getter(jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                        { return thisVal; }, "get [Symbol.species]"));
+    }
+} arrayInit;

package/src/prelude/library/console.hpp

@@ -6,6 +6,7 @@
 #include "values/object.hpp"
 #include "values/function.hpp"
 #include "utils/operators.hpp"
+#include "exception.hpp"
 #include "utils/log_any_value/log_any_value.hpp"
 
 #include <cmath>
@@ -14,7 +15,7 @@
 
 static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
 
-auto logFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto logFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                            {
                                                for (size_t i = 0; i < args.size(); ++i)
                                                {
@@ -24,7 +25,7 @@ auto logFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, con
                                                }
                                                std::cout << "\n" << std::flush;
                                                return jspp::AnyValue::make_undefined(); }, "log");
-auto warnFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto warnFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                             {
                                                 std::cerr << "\033[33m";
                                                 for (size_t i = 0; i < args.size(); ++i)
@@ -35,7 +36,7 @@ auto warnFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, co
                                                 }
                                                 std::cerr << "\033[0m" << "\n" << std::flush; // reset
                                                 return jspp::AnyValue::make_undefined(); }, "warn");
-auto errorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto errorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                              {
                                                  std::cerr << "\033[31m";
                                                  for (size_t i = 0; i < args.size(); ++i)
@@ -46,7 +47,7 @@ auto errorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, c
                                                  }
                                                  std::cerr << "\033[0m" << "\n" << std::flush; // reset
                                                  return jspp::AnyValue::make_undefined(); }, "error");
-auto timeFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto timeFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                             {
                                                 auto start = std::chrono::steady_clock::now(); // capture immediately
                                                 auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
@@ -83,7 +84,7 @@ static auto format_duration = [](double ms) -> std::string
     return ss.str();
 };
 
-auto timeEndFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto timeEndFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                                {
                                                    auto end = std::chrono::steady_clock::now(); // capture immediately
                                                    auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";

package/src/prelude/library/error.hpp

@@ -7,7 +7,7 @@
 inline jspp::AnyValue Error;
 
 // Constructor logic
-inline auto errorConstructor = [](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args) -> jspp::AnyValue
+inline auto errorConstructor = [](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
 {
     // Access global Error to get prototype
     jspp::AnyValue proto = Error.get_own_property("prototype");
@@ -18,7 +18,7 @@ inline auto errorConstructor = [](const jspp::AnyValue &thisVal, const std::vect
     if (target.is_object())
     {
         auto obj = target.as_object();
-        if (obj->proto && (*obj->proto).is_strictly_equal_to_primitive(proto))
+        if (obj->proto && is_strictly_equal_to_primitive((*obj->proto), proto))
         {
             is_construct_call = true;
         }
@@ -29,6 +29,7 @@ inline auto errorConstructor = [](const jspp::AnyValue &thisVal, const std::vect
         target = jspp::AnyValue::make_object_with_proto({}, proto);
     }
 
+    std::string name = "Error";
     std::string message = "";
     if (!args.empty() && !args[0].is_undefined())
     {
@@ -36,8 +37,8 @@ inline auto errorConstructor = [](const jspp::AnyValue &thisVal, const std::vect
     }
 
     target.define_data_property("message", jspp::AnyValue::make_string(message), true, false, true);
-    target.define_data_property("name", jspp::AnyValue::make_string("Error"), true, false, true);
-    target.define_data_property("stack", jspp::AnyValue::make_string("Error: " + message + "\n    at <unknown>"), true, false, true);
+    target.define_data_property("name", jspp::AnyValue::make_string(name), true, false, true);
+    target.define_data_property("stack", jspp::AnyValue::make_string(name + ": " + message + "\n    at <unknown>"), true, false, true);
 
     if (args.size() > 1 && args[1].is_object())
     {
@@ -52,7 +53,7 @@ inline auto errorConstructor = [](const jspp::AnyValue &thisVal, const std::vect
 };
 
 // Static Error.isError(val) implementation
-inline auto isErrorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args) -> jspp::AnyValue
+inline auto isErrorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                       {
     if (args.empty()) return jspp::AnyValue::make_boolean(false);
     
@@ -67,7 +68,7 @@ inline auto isErrorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &t
     if (val.is_object()) {
         auto current = val.as_object()->proto;
         while (current && !(*current).is_null()) {
-             if ((*current).is_strictly_equal_to_primitive(proto)) return jspp::AnyValue::make_boolean(true);
+             if (is_strictly_equal_to_primitive((*current),proto)) return jspp::AnyValue::make_boolean(true);
              if ((*current).is_object()) current = (*current).as_object()->proto;
              else break;
         }
@@ -76,7 +77,7 @@ inline auto isErrorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &t
     return jspp::AnyValue::make_boolean(false); }, "isError");
 
 // toString method for Error.prototype
-inline auto errorToStringFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args) -> jspp::AnyValue
+inline auto errorToStringFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                             {
     std::string name = "Error";
     std::string msg = "";
@@ -104,8 +105,9 @@ struct ErrorInit
         // Define Error.prototype.toString
         auto proto = Error.get_own_property("prototype");
         proto.define_data_property("toString", errorToStringFn, true, false, true);
+        proto.define_data_property(jspp::WellKnownSymbols::toStringTag->key, errorToStringFn, true, false, true);
 
         // Define static Error.isError
-        Error.define_data_property("isError", isErrorFn,true ,false,true);
+        Error.define_data_property("isError", isErrorFn, true, false, true);
     }
 } errorInit;

package/src/prelude/library/function.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+
+// Define Function constructor
+// In a full implementation, this would support 'new Function(args, body)'
+inline auto Function = jspp::AnyValue::make_class([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+    return jspp::Constants::UNDEFINED;
+}, "Function");

package/src/prelude/library/global.hpp

@@ -8,8 +8,12 @@
 
 #include "library/promise.hpp"
 #include "library/timer.hpp"
+#include "library/math.hpp"
 
 inline auto global = jspp::AnyValue::make_object({
+    {"Symbol", Symbol},
+    {"process", process},
+    {"Function", Function},
     {"console", console},
     {"performance", performance},
     {"Error", Error},
@@ -18,4 +22,20 @@ inline auto global = jspp::AnyValue::make_object({
     {"clearTimeout", clearTimeout},
     {"setInterval", setInterval},
     {"clearInterval", clearInterval},
+    {"Math", Math},
+    {"Object", Object},
+    {"Array", Array},
 });
+
+struct GlobalInit {
+    GlobalInit() {
+        auto objectProto = ::Object.get_own_property("prototype");
+        
+        // Tie built-in prototypes to Object.prototype
+        ::Array.get_own_property("prototype").set_prototype(objectProto);
+        ::Function.get_own_property("prototype").set_prototype(objectProto);
+        ::Error.get_own_property("prototype").set_prototype(objectProto);
+        ::Promise.get_own_property("prototype").set_prototype(objectProto);
+        ::Symbol.get_own_property("prototype").set_prototype(objectProto);
+    }
+} globalInit;