@ugo-studio/jspp 0.3.0 → 0.3.2

package/src/prelude/library/array.hpp

@@ -5,182 +5,9 @@
 #include "utils/operators.hpp"
 #include "utils/access.hpp"
 
-inline auto Array = jspp::AnyValue::make_class([](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>());
-        auto arr_ptr = arr.as_array();
-        arr_ptr->length = static_cast<uint64_t>(len);
-        arr_ptr->dense.resize(static_cast<size_t>(len), jspp::Constants::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");
+namespace jspp {
+    extern AnyValue Array; 
+    void init_array();
+}
 
-struct ArrayInit
-{
-    ArrayInit()
-    {
-        // Array.isArray(value)
-        Array.define_data_property("isArray", jspp::AnyValue::make_function([](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([](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([](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;
-
-            auto iteratorSym = jspp::WellKnownSymbols::iterator;
-            if (items.has_property(iteratorSym->key)) {
-                auto iter = jspp::Access::get_object_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([](jspp::AnyValue, std::vector<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::Constants::UNDEFINED;
-            jspp::AnyValue nextFn = jspp::Constants::UNDEFINED;
-
-            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([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                                                                        { return thisVal; }, "get [Symbol.species]"));
-    }
-} arrayInit;
+using jspp::Array;

package/src/prelude/library/boolean.cpp

@@ -0,0 +1,30 @@
+#include "jspp.hpp"
+#include "library/boolean.hpp"
+
+namespace jspp
+{
+    // TODO: implement boolean constructor
+    jspp::AnyValue Boolean = jspp::AnyValue::make_function(
+        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                     {
+                                                                         if (args.empty())
+                                                                             return jspp::Constants::FALSE;
+                                                                         return jspp::AnyValue::make_boolean(jspp::is_truthy(args[0])); }),
+        "Boolean");
+
+    struct BooleanInit
+    {
+        BooleanInit()
+        { // TODO: implement boolean prototypes
+          // auto proto = Boolean.get_own_property("prototype");
+          // proto.define_data_property("valueOf", jspp::BooleanPrototypes::get("valueOf").value(), true, false, true);
+          // proto.define_data_property("toString", jspp::BooleanPrototypes::get("toString").value(), true, false, true);
+        }
+    };
+
+    void init_boolean()
+    {
+        static BooleanInit booleanInit;
+    }
+
+}

package/src/prelude/library/boolean.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+#include "utils/access.hpp"
+
+namespace jspp
+{
+    extern AnyValue Boolean;
+    void init_boolean();
+}
+
+using jspp::Boolean;

package/src/prelude/library/console.cpp

@@ -0,0 +1,125 @@
+#include "jspp.hpp"
+#include "library/console.hpp"
+#include <chrono>
+#include <map>
+
+static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
+
+namespace jspp {
+    jspp::AnyValue logFn;
+    jspp::AnyValue warnFn;
+    jspp::AnyValue errorFn;
+    jspp::AnyValue timeFn;
+    jspp::AnyValue timeEndFn;
+    jspp::AnyValue console;
+
+    static auto format_duration = [](double ms) -> std::string
+    {
+        std::ostringstream ss;
+        if (ms < 1000.0)
+        {
+            ss << std::fixed << std::setprecision(4) << ms << "ms";
+            return ss.str();
+        }
+        double total_s = ms / 1000.0;
+        if (ms < 60000.0)
+        {
+            ss << std::fixed << std::setprecision(4) << total_s << "s";
+            return ss.str();
+        }
+        if (ms < 3600000.0)
+        {
+            int minutes = static_cast<int>(ms / 60000.0);
+            double seconds = (ms - minutes * 60000.0) / 1000.0;
+            ss << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
+            return ss.str();
+        }
+        int hours = static_cast<int>(ms / 3600000.0);
+        int minutes = static_cast<int>((ms - hours * 3600000.0) / 60000.0);
+        double seconds = (ms - hours * 3600000.0 - minutes * 60000.0) / 1000.0;
+        ss << hours << "h " << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
+        return ss.str();
+    };
+
+    void init_console() {
+        if (!console.is_undefined()) return;
+
+        logFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                for (size_t i = 0; i < args.size(); ++i)
+                {
+                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
+                    if (i < args.size() - 1)
+                        std::cout << " ";
+                }
+                std::cout << "\n" << std::flush;
+                return jspp::Constants::UNDEFINED;
+            }), "log");
+
+        warnFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                std::cerr << "\033[33m";
+                for (size_t i = 0; i < args.size(); ++i)
+                {
+                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
+                    if (i < args.size() - 1)
+                        std::cout << " ";
+                }
+                std::cerr << "\033[0m" << "\n" << std::flush;
+                return jspp::Constants::UNDEFINED;
+            }), "warn");
+
+        errorFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                std::cerr << "\033[31m";
+                for (size_t i = 0; i < args.size(); ++i)
+                {
+                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
+                    if (i < args.size() - 1)
+                        std::cout << " ";
+                }
+                std::cerr << "\033[0m" << "\n" << std::flush;
+                return jspp::Constants::UNDEFINED;
+            }), "error");
+
+        timeFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                auto start = std::chrono::steady_clock::now();
+                auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
+                timers[key_str] = start;
+                return jspp::Constants::UNDEFINED;
+            }), "time");
+
+        timeEndFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                auto end = std::chrono::steady_clock::now();
+                auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
+                auto it = timers.find(key_str);
+                if (it != timers.end())
+                {
+                    std::chrono::duration<double, std::milli> duration = end - it->second;
+                    double ms = duration.count();
+                    std::cout << "\033[90m" << "[" << format_duration(ms) << "] " << "\033[0m" << key_str << "\n";
+                    timers.erase(it);
+                }
+                else
+                {
+                    std::cout << "Timer '" << key_str << "' does not exist.\n";
+                }
+                return jspp::Constants::UNDEFINED;
+            }), "timeEnd");
+
+        console = jspp::AnyValue::make_object({
+            {"log", logFn},
+            {"warn", warnFn},
+            {"error", errorFn},
+            {"time", timeFn},
+            {"timeEnd", timeEndFn},
+        });
+    }
+}

package/src/prelude/library/console.hpp

@@ -13,100 +13,12 @@
 #include <sstream>
 #include <iomanip>
 
-static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
-
-auto logFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                           {
-                                               for (size_t i = 0; i < args.size(); ++i)
-                                               {
-                                                   std::cout << jspp::LogAnyValue::to_log_string(args[i]);
-                                                   if (i < args.size() - 1)
-                                                       std::cout << " ";
-                                               }
-                                               std::cout << "\n" << std::flush;
-                                               return jspp::Constants::UNDEFINED; }, "log");
-auto warnFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                            {
-                                                std::cerr << "\033[33m";
-                                                for (size_t i = 0; i < args.size(); ++i)
-                                                {
-                                                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
-                                                    if (i < args.size() - 1)
-                                                        std::cout << " ";
-                                                }
-                                                std::cerr << "\033[0m" << "\n" << std::flush; // reset
-                                                return jspp::Constants::UNDEFINED; }, "warn");
-auto errorFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                             {
-                                                 std::cerr << "\033[31m";
-                                                 for (size_t i = 0; i < args.size(); ++i)
-                                                 {
-                                                     std::cout << jspp::LogAnyValue::to_log_string(args[i]);
-                                                     if (i < args.size() - 1)
-                                                         std::cout << " ";
-                                                 }
-                                                 std::cerr << "\033[0m" << "\n" << std::flush; // reset
-                                                 return jspp::Constants::UNDEFINED; }, "error");
-auto timeFn = jspp::AnyValue::make_function([](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";
-                                                timers[key_str] = start;
-                                                return jspp::Constants::UNDEFINED; }, "time");
-
-// helper to format duration in ms -> ms/s/m/h with nice precision
-static auto format_duration = [](double ms) -> std::string
-{
-    std::ostringstream ss;
-    if (ms < 1000.0)
-    {
-        ss << std::fixed << std::setprecision(4) << ms << "ms";
-        return ss.str();
-    }
-    double total_s = ms / 1000.0;
-    if (ms < 60000.0)
-    { // less than a minute -> show seconds
-        ss << std::fixed << std::setprecision(4) << total_s << "s";
-        return ss.str();
-    }
-    if (ms < 3600000.0)
-    { // less than an hour -> show minutes + seconds
-        int minutes = static_cast<int>(ms / 60000.0);
-        double seconds = (ms - minutes * 60000.0) / 1000.0;
-        ss << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
-        return ss.str();
-    }
-    // hours, minutes, seconds
-    int hours = static_cast<int>(ms / 3600000.0);
-    int minutes = static_cast<int>((ms - hours * 3600000.0) / 60000.0);
-    double seconds = (ms - hours * 3600000.0 - minutes * 60000.0) / 1000.0;
-    ss << hours << "h " << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
-    return ss.str();
-};
-
-auto timeEndFn = jspp::AnyValue::make_function([](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";
-                                                   auto it = timers.find(key_str);
-                                                   if (it != timers.end())
-                                                   {
-                                                       std::chrono::duration<double, std::milli> duration = end - it->second;
-                                                       double ms = duration.count();
-                                                       std::string formatted = format_duration(ms);
-                                                       std::cout << "\033[90m" << "[" << format_duration(ms) << "] " << "\033[0m" << key_str << "\n";
-                                                       timers.erase(it); // remove the timer after ending it
-                                                   }
-                                                   else
-                                                   {
-                                                       std::cout << "Timer '" << key_str << "' does not exist." << "\n";
-                                                   }
-                                                   return jspp::Constants::UNDEFINED; }, "timeEnd");
-
-inline auto console = jspp::AnyValue::make_object({
-    {"log", logFn},
-    {"warn", warnFn},
-    {"error", errorFn},
-    {"time", timeFn},
-    {"timeEnd", timeEndFn},
-});
+namespace jspp {
+    extern AnyValue logFn;
+    extern AnyValue warnFn;
+    extern AnyValue errorFn;
+    extern AnyValue timeFn;
+    extern AnyValue timeEndFn;
+    extern AnyValue console; 
+    void init_console();
+}

package/src/prelude/library/error.cpp

@@ -0,0 +1,100 @@
+#include "jspp.hpp"
+#include "library/error.hpp"
+
+namespace jspp
+{
+    jspp::AnyValue Error;
+
+    auto errorConstructor = [](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+    {
+        jspp::AnyValue proto = Error.get_own_property("prototype");
+        jspp::AnyValue target = thisVal;
+        bool is_construct_call = false;
+
+        if (target.is_object())
+        {
+            auto obj = target.as_object();
+            if (!obj->proto.is_null() && !obj->proto.is_undefined() && is_strictly_equal_to_native(obj->proto, proto))
+            {
+                is_construct_call = true;
+            }
+        }
+
+        if (!is_construct_call)
+        {
+            target = jspp::AnyValue::make_object({}).set_prototype(proto);
+        }
+
+        std::string name = "Error";
+        std::string message = "";
+        if (!args.empty() && !args[0].is_undefined())
+        {
+            message = args[0].to_std_string();
+        }
+
+        target.define_data_property("message", jspp::AnyValue::make_string(message), 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())
+        {
+            jspp::AnyValue cause = args[1].get_own_property("cause");
+            if (!cause.is_undefined())
+            {
+                target.define_data_property("cause", cause, true, false, true);
+            }
+        }
+
+        return target;
+    };
+
+    jspp::AnyValue isErrorFn = jspp::AnyValue::make_function(
+        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                     {
+        if (args.empty()) return jspp::Constants::FALSE;
+        jspp::AnyValue val = args[0];
+        if (!val.is_object()) return jspp::Constants::FALSE;
+        jspp::AnyValue proto = Error.get_own_property("prototype");
+        if (val.is_object()) {
+            auto current = val.as_object()->proto;
+            while (!current.is_null()) {
+                 if (is_strictly_equal_to_native(current, proto)) return jspp::Constants::TRUE;
+                 if (current.is_object()) current = current.as_object()->proto;
+                 else break;
+            }
+        }
+        return jspp::Constants::FALSE; }),
+        "isError");
+
+    jspp::AnyValue errorToStringFn = jspp::AnyValue::make_function(
+        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                     {
+        std::string name = "Error";
+        std::string msg = "";
+        jspp::AnyValue n = thisVal.get_own_property("name");
+        if (!n.is_undefined()) name = n.to_std_string();
+        jspp::AnyValue m = thisVal.get_own_property("message");
+        if (!m.is_undefined()) msg = m.to_std_string();
+        if (name.empty() && msg.empty()) return jspp::AnyValue::make_string("Error");
+        if (name.empty()) return jspp::AnyValue::make_string(msg);
+        if (msg.empty()) return jspp::AnyValue::make_string(name);
+        return jspp::AnyValue::make_string(name + ": " + msg); }),
+        "toString");
+
+    struct ErrorInit
+    {
+        ErrorInit()
+        {
+            Error = jspp::AnyValue::make_class(
+                std::function<AnyValue(AnyValue, std::span<const AnyValue>)>(errorConstructor), "Error");
+            auto proto = Error.get_own_property("prototype");
+            proto.define_data_property("toString", errorToStringFn, true, false, true);
+            proto.define_data_property(jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toStringTag), errorToStringFn, true, false, true);
+            Error.define_data_property("isError", isErrorFn, true, false, true);
+        }
+    };
+    void init_error()
+    {
+        static ErrorInit errorInit;
+    }
+}